couchbase 4.0.0 → 4.1.0

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/demangle.hpp

@@ -1,5 +1,5 @@
-// Copyright (c) 2014-2021 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL
+// Copyright (c) 2014-2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
 #ifndef TAO_PEGTL_DEMANGLE_HPP
 #define TAO_PEGTL_DEMANGLE_HPP
@@ -9,26 +9,43 @@
 
 #include "config.hpp"
 
+// ensure a consistent interface
 namespace TAO_PEGTL_NAMESPACE
 {
+#if !defined( __clang__ ) && defined( __GNUC__ ) && ( __GNUC__ == 7 )
+
+   template< typename T >
+   [[nodiscard]] std::string_view demangle() noexcept;
+
+#else
+
+   template< typename T >
+   [[nodiscard]] constexpr std::string_view demangle() noexcept;
+
+#endif
+
+}  // namespace TAO_PEGTL_NAMESPACE
+
 #if defined( __clang__ )
 
 #if defined( _LIBCPP_VERSION )
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      constexpr std::string_view sv = __PRETTY_FUNCTION__;
-      constexpr auto begin = sv.find( '=' );
-      static_assert( begin != std::string_view::npos );
-      return sv.substr( begin + 2, sv.size() - begin - 3 );
-   }
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   constexpr std::string_view sv = __PRETTY_FUNCTION__;
+   constexpr auto begin = sv.find( '=' );
+   static_assert( begin != std::string_view::npos );
+   return sv.substr( begin + 2, sv.size() - begin - 3 );
+}
 
 #else
 
+namespace TAO_PEGTL_NAMESPACE::internal
+{
    // When using libstdc++ with clang, std::string_view::find is not constexpr :(
    template< char C >
-   constexpr const char* find( const char* p, std::size_t n ) noexcept
+   constexpr const char* string_view_find( const char* p, std::size_t n ) noexcept
    {
       while( n ) {
          if( *p == C ) {
@@ -40,14 +57,16 @@ namespace TAO_PEGTL_NAMESPACE
       return nullptr;
    }
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      constexpr std::string_view sv = __PRETTY_FUNCTION__;
-      constexpr auto begin = find< '=' >( sv.data(), sv.size() );
-      static_assert( begin != nullptr );
-      return { begin + 2, sv.data() + sv.size() - begin - 3 };
-   }
+}  // namespace TAO_PEGTL_NAMESPACE::internal
+
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   constexpr std::string_view sv = __PRETTY_FUNCTION__;
+   constexpr auto begin = internal::string_view_find< '=' >( sv.data(), sv.size() );
+   static_assert( begin != nullptr );
+   return { begin + 2, sv.data() + sv.size() - begin - 3 };
+}
 
 #endif
 
@@ -55,42 +74,50 @@ namespace TAO_PEGTL_NAMESPACE
 
 #if( __GNUC__ == 7 )
 
-   // GCC 7 wrongly sometimes disallows __PRETTY_FUNCTION__ in constexpr functions,
-   // therefore we drop the 'constexpr' and hope for the best.
-   template< typename T >
-   [[nodiscard]] std::string_view demangle() noexcept
-   {
-      const std::string_view sv = __PRETTY_FUNCTION__;
-      const auto begin = sv.find( '=' );
-      const auto tmp = sv.substr( begin + 2 );
-      const auto end = tmp.rfind( ';' );
-      return tmp.substr( 0, end );
-   }
+// GCC 7 wrongly sometimes disallows __PRETTY_FUNCTION__ in constexpr functions,
+// therefore we drop the 'constexpr' and hope for the best.
+template< typename T >
+[[nodiscard]] std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   const std::string_view sv = __PRETTY_FUNCTION__;
+   const auto begin = sv.find( '=' );
+   const auto tmp = sv.substr( begin + 2 );
+   const auto end = tmp.rfind( ';' );
+   return tmp.substr( 0, end );
+}
 
 #elif( __GNUC__ == 9 ) && ( __GNUC_MINOR__ < 3 )
 
-   // GCC 9.1 and 9.2 have a bug that leads to truncated __PRETTY_FUNCTION__ names,
-   // see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91155
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      // fallback: requires RTTI, no demangling
-      return typeid( T ).name();
-   }
+#if !defined( __cpp_rtti )
+#error "RTTI support required for GCC 9.1/9.2"
+#else
+
+#include <typeinfo>
+
+// GCC 9.1 and 9.2 have a bug that leads to truncated __PRETTY_FUNCTION__ names,
+// see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91155
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   // fallback: requires RTTI, no demangling
+   return typeid( T ).name();
+}
+
+#endif
 
 #else
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      constexpr std::string_view sv = __PRETTY_FUNCTION__;
-      constexpr auto begin = sv.find( '=' );
-      static_assert( begin != std::string_view::npos );
-      constexpr auto tmp = sv.substr( begin + 2 );
-      constexpr auto end = tmp.rfind( ';' );
-      static_assert( end != std::string_view::npos );
-      return tmp.substr( 0, end );
-   }
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   constexpr std::string_view sv = __PRETTY_FUNCTION__;
+   constexpr auto begin = sv.find( '=' );
+   static_assert( begin != std::string_view::npos );
+   constexpr auto tmp = sv.substr( begin + 2 );
+   constexpr auto end = tmp.rfind( ';' );
+   static_assert( end != std::string_view::npos );
+   return tmp.substr( 0, end );
+}
 
 #endif
 
@@ -98,43 +125,51 @@ namespace TAO_PEGTL_NAMESPACE
 
 #if( _MSC_VER < 1920 )
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      const std::string_view sv = __FUNCSIG__;
-      const auto begin = sv.find( "demangle<" );
-      const auto tmp = sv.substr( begin + 9 );
-      const auto end = tmp.rfind( '>' );
-      return tmp.substr( 0, end );
-   }
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   const std::string_view sv = __FUNCSIG__;
+   const auto begin = sv.find( "demangle<" );
+   const auto tmp = sv.substr( begin + 9 );
+   const auto end = tmp.rfind( '>' );
+   return tmp.substr( 0, end );
+}
 
 #else
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      constexpr std::string_view sv = __FUNCSIG__;
-      constexpr auto begin = sv.find( "demangle<" );
-      static_assert( begin != std::string_view::npos );
-      constexpr auto tmp = sv.substr( begin + 9 );
-      constexpr auto end = tmp.rfind( '>' );
-      static_assert( end != std::string_view::npos );
-      return tmp.substr( 0, end );
-   }
+#include "internal/dependent_true.hpp"
+
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   constexpr std::string_view sv = __FUNCSIG__;
+   constexpr auto begin = sv.find( "demangle<" );
+   static_assert( internal::dependent_true< T > && ( begin != std::string_view::npos ) );
+   constexpr auto tmp = sv.substr( begin + 9 );
+   constexpr auto end = tmp.rfind( '>' );
+   static_assert( internal::dependent_true< T > && ( end != std::string_view::npos ) );
+   return tmp.substr( 0, end );
+}
 
 #endif
 
 #else
 
-   template< typename T >
-   [[nodiscard]] constexpr std::string_view demangle() noexcept
-   {
-      // fallback: requires RTTI, no demangling
-      return typeid( T ).name();
-   }
+#if !defined( __cpp_rtti )
+#error "RTTI support required for unknown compilers"
+#else
+
+#include <typeinfo>
+
+template< typename T >
+[[nodiscard]] constexpr std::string_view TAO_PEGTL_NAMESPACE::demangle() noexcept
+{
+   // fallback: requires RTTI, no demangling
+   return typeid( T ).name();
+}
 
 #endif
 
-}  // namespace TAO_PEGTL_NAMESPACE
+#endif
 
 #endif

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/internal/dependent_true.hpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2022 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_INTERNAL_DEPENDENT_TRUE_HPP
+#define TAO_PEGTL_INTERNAL_DEPENDENT_TRUE_HPP
+
+#include "../config.hpp"
+
+namespace TAO_PEGTL_NAMESPACE::internal
+{
+   template< typename... >
+   inline constexpr bool dependent_true = true;
+
+}  // namespace TAO_PEGTL_NAMESPACE::internal
+
+#endif

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/internal/state.hpp

@@ -6,6 +6,9 @@
 
 #include "../config.hpp"
 
+#include <type_traits>
+
+#include "dependent_false.hpp"
 #include "enable_control.hpp"
 #include "seq.hpp"
 #include "success.hpp"
@@ -16,18 +19,18 @@
 
 namespace TAO_PEGTL_NAMESPACE::internal
 {
-   template< typename State, typename... Rules >
+   template< typename NewState, typename... Rules >
    struct state
-      : state< State, seq< Rules... > >
+      : state< NewState, seq< Rules... > >
    {};
 
-   template< typename State >
-   struct state< State >
+   template< typename NewState >
+   struct state< NewState >
       : success
    {};
 
-   template< typename State, typename Rule >
-   struct state< State, Rule >
+   template< typename NewState, typename Rule >
+   struct state< NewState, Rule >
    {
       using rule_t = state;
       using subs_t = type_list< Rule >;
@@ -42,17 +45,30 @@ namespace TAO_PEGTL_NAMESPACE::internal
                 typename... States >
       [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
-         State s( static_cast< const ParseInput& >( in ), st... );
-         if( Control< Rule >::template match< A, M, Action, Control >( in, s ) ) {
-            s.success( static_cast< const ParseInput& >( in ), st... );
-            return true;
+         if constexpr( std::is_constructible_v< NewState, const ParseInput&, States... > ) {
+            NewState s( static_cast< const ParseInput& >( in ), st... );
+            if( Control< Rule >::template match< A, M, Action, Control >( in, s ) ) {
+               s.success( static_cast< const ParseInput& >( in ), st... );
+               return true;
+            }
+            return false;
+         }
+         else if constexpr( std::is_default_constructible_v< NewState > ) {
+            NewState s;
+            if( Control< Rule >::template match< A, M, Action, Control >( in, s ) ) {
+               s.success( static_cast< const ParseInput& >( in ), st... );
+               return true;
+            }
+            return false;
+         }
+         else {
+            static_assert( internal::dependent_false< NewState >, "unable to instantiate new state" );
          }
-         return false;
       }
    };
 
-   template< typename State, typename... Rules >
-   inline constexpr bool enable_control< state< State, Rules... > > = false;
+   template< typename NewState, typename... Rules >
+   inline constexpr bool enable_control< state< NewState, Rules... > > = false;
 
 }  // namespace TAO_PEGTL_NAMESPACE::internal
 

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/version.hpp

@@ -1,13 +1,13 @@
-// Copyright (c) 2017-2021 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2017-2022 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
 #ifndef TAO_PEGTL_VERSION_HPP
 #define TAO_PEGTL_VERSION_HPP
 
-#define TAO_PEGTL_VERSION "3.2.1"
+#define TAO_PEGTL_VERSION "3.2.5"
 
 #define TAO_PEGTL_VERSION_MAJOR 3
 #define TAO_PEGTL_VERSION_MINOR 2
-#define TAO_PEGTL_VERSION_PATCH 1
+#define TAO_PEGTL_VERSION_PATCH 5
 
 #endif

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/src/example/pegtl/CMakeLists.txt

@@ -11,6 +11,7 @@ set(example_sources
   expression.cpp
   hello_world.cpp
   indent_aware.cpp
+  iri.cpp
   json_analyze.cpp
   json_ast.cpp
   json_build.cpp

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/src/example/pegtl/iri.cpp

@@ -0,0 +1,101 @@
+// Copyright (c) 2021 Kelvin Hammond
+// Copyright (c) 2021 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#if !defined( __cpp_exceptions )
+#include <iostream>
+int main()
+{
+   std::cerr << "Exception support required, example unavailable." << std::endl;
+   return 1;
+}
+#else
+
+#include <tao/pegtl.hpp>
+#include <tao/pegtl/contrib/iri.hpp>
+
+#include <iostream>
+
+namespace pegtl = TAO_PEGTL_NAMESPACE;
+
+struct IRI
+{
+   std::string scheme;
+   std::string authority;
+   std::string userinfo;
+   std::string host;
+   std::string port;
+   std::string path;
+   std::string query;
+   std::string fragment;
+
+   explicit IRI( const std::string& iri );
+};
+
+namespace iri
+{
+   template< std::string IRI::*Field >
+   struct bind
+   {
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, IRI& iri )
+      {
+         iri.*Field = in.string();
+      }
+   };
+
+   // clang-format off
+   template< typename Rule > struct action {};
+
+   template<> struct action< pegtl::iri::scheme > : bind< &IRI::scheme > {};
+   template<> struct action< pegtl::iri::iauthority > : bind< &IRI::authority > {};
+   // userinfo: see below
+   template<> struct action< pegtl::iri::ihost > : bind< &IRI::host > {};
+   template<> struct action< pegtl::iri::port > : bind< &IRI::port > {};
+   template<> struct action< pegtl::iri::ipath_noscheme > : bind< &IRI::path > {};
+   template<> struct action< pegtl::iri::ipath_rootless > : bind< &IRI::path > {};
+   template<> struct action< pegtl::iri::ipath_absolute > : bind< &IRI::path > {};
+   template<> struct action< pegtl::iri::ipath_abempty > : bind< &IRI::path > {};
+   template<> struct action< pegtl::iri::iquery > : bind< &IRI::query > {};
+   template<> struct action< pegtl::iri::ifragment > : bind< &IRI::fragment > {};
+   // clang-format on
+
+   template<>
+   struct action< pegtl::iri::opt_iuserinfo >
+   {
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, IRI& iri )
+      {
+         if( !in.empty() ) {
+            iri.userinfo = std::string( in.begin(), in.size() - 1 );
+         }
+      }
+   };
+
+}  // namespace iri
+
+IRI::IRI( const std::string& iri )
+{
+   using grammar = pegtl::must< pegtl::iri::IRI >;
+   pegtl::memory_input input( iri, "iri" );
+   pegtl::parse< grammar, iri::action >( input, *this );
+}
+
+int main( int argc, char** argv )
+{
+   for( int i = 1; i < argc; ++i ) {
+      std::cout << "Parsing " << argv[ i ] << std::endl;
+      const IRI iri( argv[ i ] );
+      std::cout << "IRI.scheme: " << iri.scheme << std::endl;
+      std::cout << "IRI.authority: " << iri.authority << std::endl;
+      std::cout << "IRI.userinfo: " << iri.userinfo << std::endl;
+      std::cout << "IRI.host: " << iri.host << std::endl;
+      std::cout << "IRI.port: " << iri.port << std::endl;
+      std::cout << "IRI.path: " << iri.path << std::endl;
+      std::cout << "IRI.query: " << iri.query << std::endl;
+      std::cout << "IRI.fragment: " << iri.fragment << std::endl;
+   }
+   return 0;
+}
+
+#endif

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/src/example/pegtl/proto3.cpp

@@ -14,122 +14,7 @@ int main()
 
 #include <tao/pegtl.hpp>
 #include <tao/pegtl/contrib/analyze.hpp>
-
-namespace TAO_PEGTL_NAMESPACE::proto3
-{
-   // clang-format off
-   struct comment : seq< two< '/' >, until< eolf > > {};
-   struct sp : sor< space, comment > {};
-   struct sps : star< sp > {};
-
-   struct comma : one< ',' > {};
-   struct dot : one< '.' > {};
-   struct equ : one< '=' > {};
-   struct semi : one< ';' > {};
-
-   struct option;
-   struct message;
-
-   struct odigit : range< '0', '7' > {};
-
-   struct ident_first : ranges< 'a', 'z', 'A', 'Z' > {};  // NOTE: Yes, no '_'.
-   struct ident_other : ranges< 'a', 'z', 'A', 'Z', '0', '9', '_' > {};
-   struct ident : seq< ident_first, star< ident_other > > {};
-   struct full_ident : list_must< ident, dot > {};
-
-   struct oct_lit : seq< one< '0' >, star< odigit > > {};
-   struct hex_lit : seq< one< '0' >, one< 'x', 'X' >, plus< xdigit > > {};
-   struct dec_lit : seq< range< '1', '9' >, star< digit > > {};
-   struct int_lit : sor< dec_lit, hex_lit, oct_lit > {};
-
-   struct hex_escape : if_must< one< 'x', 'X' >, xdigit, xdigit > {};
-   struct oct_escape : if_must< odigit, odigit, odigit > {};
-   struct char_escape : one< 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '"' > {};
-   struct escape : if_must< one< '\\' >, hex_escape, oct_escape, char_escape > {};
-   struct char_value : sor< escape, not_one< '\n', '\0' > > {};  // NOTE: No need to exclude '\' from not_one<>, see escape rule.
-   template< char Q >
-   struct str_impl : if_must< one< Q >, until< one< Q >, char_value > > {};
-   struct str_lit : sor< str_impl< '\'' >, str_impl< '"' > > {};
-
-   struct bool_lit : seq< sor< string< 't', 'r', 'u', 'e' >, string< 'f', 'a', 'l', 's', 'e' > >, not_at< ident_other > > {};
-
-   struct sign : one< '+', '-' > {};
-   struct constant : sor< bool_lit, full_ident, seq< opt< sign >, int_lit >, str_lit > {};  // TODO: Needs sps after sign?
-
-   struct option_name : seq< sor< ident, if_must< one< '(' >, full_ident, one< ')' > > >, star_must< dot, ident > > {};
-   struct option : if_must< string< 'o', 'p', 't', 'i', 'o', 'n' >, sps, option_name, sps, equ, sps, constant, sps, semi, sps > {};
-
-   struct bool_type : string< 'b', 'o', 'o', 'l' > {};
-   struct bytes_type : string< 'b', 'y', 't', 'e', 's' > {};
-   struct double_type : string< 'd', 'o', 'u', 'b', 'l', 'e' > {};
-   struct float_type : string< 'f', 'l', 'o', 'a', 't' > {};
-   struct string_type : string< 's', 't', 'r', 'i', 'n', 'g' > {};
-
-   struct int32_type : string< 'i', 'n', 't', '3', '2' > {};
-   struct int64_type : string< 'i', 'n', 't', '6', '4' > {};
-   struct sint32_type : string< 's', 'i', 'n', 't', '3', '2' > {};
-   struct sint64_type : string< 's', 'i', 'n', 't', '6', '4' > {};
-   struct uint32_type : string< 'u', 'i', 'n', 't', '3', '2' > {};
-   struct uint64_type : string< 'u', 'i', 'n', 't', '6', '4' > {};
-   struct fixed32_type : string< 'f', 'i', 'x', 'e', 'd', '3', '2' > {};
-   struct fixed64_type : string< 'f', 'i', 'x', 'e', 'd', '6', '4' > {};
-   struct sfixed32_type : string< 's', 'f', 'i', 'x', 'e', 'd', '3', '2' > {};
-   struct sfixed64_type : string< 's', 'f', 'i', 'x', 'e', 'd', '6', '4' > {};
-
-   struct builtin_type : seq< sor< bool_type, bytes_type, double_type, float_type, string_type, int32_type, int64_type, sint32_type, sint64_type, uint32_type, uint64_type, fixed32_type, fixed64_type, sfixed32_type, sfixed64_type >, not_at< ident_other > > {};
-
-   struct defined_type : seq< opt< dot >, full_ident > {};  // NOTE: This replaces both message_type and enum_type -- they have the same syntax.
-
-   struct type : sor< builtin_type, defined_type > {};
-
-   struct field_option : if_must< option_name, sps, equ, sps, constant > {};
-   struct field_options : if_must< one< '[' >, sps, list< field_option, comma, sp >, sps, one< ']' > > {};
-   struct field_name : ident {};
-   struct field_number : int_lit {};
-   struct field : seq< opt< string< 'r', 'e', 'p', 'e', 'a', 't', 'e', 'd' >, sps >, type, sps, field_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
-
-   struct oneof_name : ident {};
-   struct oneof_field : if_must< type, sps, field_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
-   struct oneof_body : sor< oneof_field, semi > {};
-   struct oneof : if_must< string< 'o', 'n', 'e', 'o', 'f' >, sps, oneof_name, sps, one< '{' >, sps, until< one< '}' >, oneof_body, sps >, sps > {};
-
-   struct key_type : seq< sor< bool_type, string_type, int32_type, int64_type, sint32_type, sint64_type, uint32_type, uint64_type, fixed32_type, fixed64_type, sfixed32_type, sfixed64_type >, not_at< ident_other > > {};
-   struct map_name : ident {};
-   struct map_field : if_must< string< 'm', 'a', 'p' >, sps, one< '<' >, sps, key_type, sps, comma, sps, type, sps, one< '>' >, sps, map_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
-
-   struct range : if_must< int_lit, sps, string< 't', 'o' >, sps, sor< int_lit, string< 'm', 'a', 'x' > > > {};
-   struct ranges : list_must< range, comma, sp > {};
-   struct field_names : list_must< field_name, comma, sp > {};
-   struct reserved : if_must< string< 'r', 'e', 's', 'e', 'r', 'v', 'e', 'd' >, sps, sor< ranges, field_names >, sps, semi > {};
-
-   struct enum_name : ident {};
-   struct enum_value_option : seq< option_name, sps, equ, sps, constant > {};
-   struct enum_field : seq< ident, sps, equ, sps, int_lit, sps, opt_must< one< '[' >, sps, list_must< enum_value_option, comma, sp >, sps, one< ']' >, sps >, semi > {};
-   struct enum_body : if_must< one< '{' >, sps, star< sor< option, enum_field, semi >, sps >, one< '}' > > {};
-   struct enum_def : if_must< string< 'e', 'n', 'u', 'm' >, sps, enum_name, sps, enum_body > {};
-
-   struct message_thing : sor< field, enum_def, message, option, oneof, map_field, reserved, semi > {};
-   struct message : if_must< string< 'm', 'e', 's', 's', 'a', 'g', 'e' >, sps, ident, sps, one< '{' >, sps, star< message_thing, sps >, one< '}' >, sps > {};
-
-   struct package : if_must< string< 'p', 'a', 'c', 'k', 'a', 'g', 'e' >, sps, full_ident, sps, semi, sps > {};
-
-   struct import_option : opt< sor< string< 'w', 'e', 'a', 'k' >, string< 'p', 'u', 'b', 'l', 'i', 'c' > > > {};
-   struct import : if_must< string< 'i', 'm', 'p', 'o', 'r', 't' >, sps, import_option, sps, str_lit, sps, semi, sps > {};
-
-   struct rpc_name : ident {};
-   struct rpc_type : if_must< one< '(' >, sps, opt< string< 's', 't', 'r', 'e', 'a', 'm' >, sps >, defined_type, sps, one< ')' > > {};
-   struct rpc_options : if_must< one< '{' >, sps, star< sor< option, semi >, sps >, one< '}' > > {};
-   struct rpc : if_must< string< 'r', 'p', 'c' >, sps, rpc_name, sps, rpc_type, sps, string< 'r', 'e', 't', 'u', 'r', 'n', 's' >, sps, rpc_type, sor< semi, rpc_options > > {};
-   struct service_name : ident {};
-   struct service : if_must< string< 's', 'e', 'r', 'v', 'i', 'c', 'e' >, sps, service_name, sps, one< '{' >, sps, list_must< sor< option, rpc, semi >, comma, sp >, sps, one< '}' > > {};
-
-   struct body : sor< import, package, option, message, enum_def, service, semi > {};
-
-   struct head : if_must< string< 's', 'y', 'n', 't', 'a', 'x' >, sps, equ, sps, string< '"', 'p', 'r', 'o', 't', 'o', '3', '"' >, sps, semi > {};
-   struct proto : must< sps, head, sps, star< body, sps >, eof > {};
-   // clang-format on
-
-}  // namespace TAO_PEGTL_NAMESPACE::proto3
+#include <tao/pegtl/contrib/proto3.hpp>
 
 int main( int argc, char** argv )  // NOLINT(bugprone-exception-escape)
 {

package/deps/couchbase-cxx-client/third_party/json/external/PEGTL/src/test/pegtl/CMakeLists.txt

@@ -34,6 +34,7 @@ set(test_sources
   contrib_if_then.cpp
   contrib_instantiate.cpp
   contrib_integer.cpp
+  contrib_iri.cpp
   contrib_json.cpp
   contrib_parse_tree.cpp
   contrib_parse_tree_to_dot.cpp
@@ -45,6 +46,7 @@ set(test_sources
   contrib_remove_last_states.cpp
   contrib_rep_one_min_max.cpp
   contrib_rep_string.cpp
+  contrib_separated_seq.cpp
   contrib_state_control.cpp
   contrib_to_string.cpp
   contrib_trace1.cpp