Update PEGTL

Author: d-frey

include/tao/json/external/pegtl/argv_input.hpp

@@ -27,28 +27,15 @@ namespace tao
             return os.str();
          }
 
-         struct argv_holder
-         {
-            const std::string argv_source;
-
-            template< typename T >
-            explicit argv_holder( T&& in_argv_source )
-               : argv_source( std::forward< T >( in_argv_source ) )
-            {
-            }
-         };
-
       }  // namespace internal
 
-      template< typename Eol = lf_crlf_eol, tracking_mode P = tracking_mode::IMMEDIATE >
+      template< tracking_mode P = tracking_mode::IMMEDIATE, typename Eol = lf_crlf_eol >
       struct argv_input
-         : private internal::argv_holder,
-           public memory_input< Eol, P >
+         : public memory_input< P, Eol >
       {
          template< typename T >
          argv_input( char** argv, const std::size_t argn, T&& in_source )
-            : internal::argv_holder( std::forward< T >( in_source ) ),
-              memory_input< Eol, P >( static_cast< const char* >( argv[ argn ] ), argv_source )
+            : memory_input< P, Eol >( static_cast< const char* >( argv[ argn ] ), std::forward< T >( in_source ) )
          {
          }
 

include/tao/json/external/pegtl/buffer_input.hpp

@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstring>
 #include <memory>
+#include <string>
 
 #include "config.hpp"
 #include "eol.hpp"
@@ -23,30 +24,29 @@ namespace tao
 {
    namespace TAOCPP_JSON_PEGTL_NAMESPACE
    {
-      template< typename Reader, typename Eol = lf_crlf_eol >
+      template< typename Reader, typename Eol = lf_crlf_eol, typename Source = std::string >
       class buffer_input
       {
       public:
+         static constexpr tracking_mode tracking_mode_v = tracking_mode::IMMEDIATE;
          using reader_t = Reader;
+
          using eol_t = Eol;
+         using source_t = Source;
+
+         using iterator_t = internal::iterator;
 
-         using memory_t = memory_input< Eol >;
-         using action_t = internal::action_input< Eol, tracking_mode::IMMEDIATE >;
+         using memory_t = memory_input< tracking_mode::IMMEDIATE, Eol, Source >;
+         using action_t = internal::action_input< buffer_input, tracking_mode::IMMEDIATE >;
 
          template< typename... As >
-         buffer_input( const char* in_source, const std::size_t maximum, As&&... as )
+         buffer_input( Source in_source, const std::size_t maximum, As&&... as )
             : m_reader( std::forward< As >( as )... ),
               m_maximum( maximum ),
               m_buffer( new char[ maximum ] ),
-              m_data( { 0, 1, 0, m_buffer.get() } ),
+              m_current( { 0, 1, 0, m_buffer.get() } ),
               m_end( m_buffer.get() ),
-              m_source( in_source )
-         {
-         }
-
-         template< typename... As >
-         buffer_input( const std::string& in_source, As&&... as )
-            : buffer_input( in_source.c_str(), std::forward< As >( as )... )
+              m_source( std::move( in_source ) )
          {
          }
 
@@ -56,18 +56,18 @@ namespace tao
          bool empty()
          {
             require( 1 );
-            return m_data.data == m_end;
+            return m_current.data == m_end;
          }
 
          std::size_t size( const std::size_t amount )
          {
             require( amount );
-            return std::size_t( m_end - m_data.data );
+            return std::size_t( m_end - m_current.data );
          }
 
-         const char* begin() const noexcept
+         const char* current() const noexcept
          {
-            return m_data.data;
+            return m_current.data;
          }
 
          const char* end( const std::size_t amount )
@@ -78,27 +78,27 @@ namespace tao
 
          std::size_t byte() const noexcept
          {
-            return m_data.byte;
+            return m_current.byte;
          }
 
          std::size_t line() const noexcept
          {
-            return m_data.line;
+            return m_current.line;
          }
 
          std::size_t byte_in_line() const noexcept
          {
-            return m_data.byte_in_line;
+            return m_current.byte_in_line;
          }
 
-         const char* source() const noexcept
+         const Source& source() const noexcept
          {
             return m_source;
          }
 
          char peek_char( const std::size_t offset = 0 ) const noexcept
          {
-            return m_data.data[ offset ];
+            return m_current.data[ offset ];
          }
 
          unsigned char peek_byte( const std::size_t offset = 0 ) const noexcept
@@ -108,32 +108,32 @@ namespace tao
 
          void bump( const std::size_t in_count = 1 ) noexcept
          {
-            internal::bump( m_data, in_count, Eol::ch );
+            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_data, in_count );
+            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_data, in_count );
+            internal::bump_to_next_line( m_current, in_count );
          }
 
          void discard() noexcept
          {
-            const auto s = m_end - m_data.data;
-            std::memmove( m_buffer.get(), m_data.data, s );
-            m_data.data = m_buffer.get();
+            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_data.data + amount > m_end ) {
-               if( m_data.data + amount <= m_buffer.get() + m_maximum ) {
-                  if( const auto r = m_reader( const_cast< char* >( m_end ), amount - std::size_t( m_end - m_data.data ) ) ) {
+            if( m_current.data + amount > m_end ) {
+               if( m_current.data + amount <= m_buffer.get() + m_maximum ) {
+                  if( const auto r = m_reader( const_cast< char* >( m_end ), amount - std::size_t( m_end - m_current.data ) ) ) {
                      m_end += r;
                   }
                   else {
@@ -144,28 +144,33 @@ namespace tao
          }
 
          template< rewind_mode M >
-         internal::marker< internal::iterator, M > mark() noexcept
+         internal::marker< iterator_t, M > mark() noexcept
+         {
+            return internal::marker< iterator_t, M >( m_current );
+         }
+
+         TAOCPP_JSON_PEGTL_NAMESPACE::position position( const iterator_t& it ) const noexcept
          {
-            return internal::marker< internal::iterator, M >( m_data );
+            return TAOCPP_JSON_PEGTL_NAMESPACE::position( it, m_source );
          }
 
          TAOCPP_JSON_PEGTL_NAMESPACE::position position() const noexcept
          {
-            return TAOCPP_JSON_PEGTL_NAMESPACE::position( m_data, m_source );
+            return position( m_current );
          }
 
-         const internal::iterator& iterator() const noexcept
+         const iterator_t& iterator() const noexcept
          {
-            return m_data;
+            return m_current;
          }
 
       private:
          Reader m_reader;
          std::size_t m_maximum;
          std::unique_ptr< char[] > m_buffer;
-         internal::iterator m_data;
+         iterator_t m_current;
          const char* m_end;
-         const char* const m_source;
+         const Source m_source;
       };
 
    }  // namespace TAOCPP_JSON_PEGTL_NAMESPACE

include/tao/json/external/pegtl/contrib/raw_string.hpp

@@ -44,18 +44,6 @@ namespace tao
             }
          };
 
-         void raw_adjust( const char*& i, const std::size_t s ) noexcept
-         {
-            i -= s;
-         }
-
-         void raw_adjust( iterator& i, const std::size_t s ) noexcept
-         {
-            i.byte -= s;
-            i.byte_in_line -= s;
-            i.data -= s;
-         }
-
          template< typename Tag >
          struct raw_string_state_apply< true, false, Tag >
          {
@@ -66,9 +54,7 @@ namespace tao
                       typename... States >
             static void success( const State& s, const Input& in, States&&... st )
             {
-               auto dend = in.iterator();
-               raw_adjust( dend, s.marker_size );
-               Control< Tag >::template apply< Action >( s.iter, dend, in, st... );
+               Control< Tag >::template apply< Action >( s.iter, in, st... );
             }
          };
 
@@ -100,11 +86,12 @@ namespace tao
                       template< typename... > class Control,
                       typename Input,
                       typename... States >
-            void success( const Input& in, States&&... st ) const
+            void success( Input& in, States&&... st ) const
             {
                constexpr bool use_action = ( A == apply_mode::ACTION ) && ( !is_nothing< Action, Tag >::value );
                constexpr bool use_apply0 = use_action && has_apply0< Action< Tag >, type_list< States... > >::value;
                raw_string_state_apply< use_action, use_apply0, Tag >::template success< Action, Control >( *this, in, st... );
+               in.bump_in_this_line( marker_size );
             }
 
             raw_string_state( const raw_string_state& ) = delete;
@@ -154,7 +141,7 @@ namespace tao
          };
 
          template< char Marker, char Close >
-         struct raw_string_close
+         struct at_raw_string_close
          {
             using analyze_t = analysis::generic< analysis::rule_type::ANY >;
 
@@ -180,13 +167,12 @@ namespace tao
                      return false;
                   }
                }
-               in.bump( ls.marker_size );
                return true;
             }
          };
 
          template< char Marker, char Close >
-         struct skip_control< raw_string_close< Marker, Close > > : std::true_type
+         struct skip_control< at_raw_string_close< Marker, Close > > : std::true_type
          {
          };
 
@@ -250,13 +236,13 @@ namespace tao
       struct raw_string
          : internal::raw_string_switch_state< internal::raw_string_tag< Open, Marker, Close >,
                                               internal::raw_string_open< Open, Marker >,
-                                              internal::must< internal::until< internal::raw_string_close< Marker, Close > > > >
+                                              internal::must< internal::until< internal::at_raw_string_close< Marker, Close > > > >
       {
          // This is used to bind an action to the content.
          using content = internal::raw_string_tag< Open, Marker, Close >;
 
          // This is used for error-reporting when a raw string is not closed properly.
-         using close = internal::until< internal::raw_string_close< Marker, Close > >;
+         using close = internal::until< internal::at_raw_string_close< Marker, Close > >;
       };
 
    }  // namespace TAOCPP_JSON_PEGTL_NAMESPACE

include/tao/json/external/pegtl/file_input.hpp

@@ -23,11 +23,11 @@ namespace tao
    namespace TAOCPP_JSON_PEGTL_NAMESPACE
    {
 #if defined( _POSIX_MAPPED_FILES )
-      template< typename Eol = lf_crlf_eol, tracking_mode P = tracking_mode::IMMEDIATE >
-      using file_input = mmap_input< Eol, P >;
+      template< tracking_mode P = tracking_mode::IMMEDIATE, typename Eol = lf_crlf_eol >
+      using file_input = mmap_input< P, Eol >;
 #else
-      template< typename Eol = lf_crlf_eol, tracking_mode P = tracking_mode::IMMEDIATE >
-      using file_input = read_input< Eol, P >;
+      template< tracking_mode P = tracking_mode::IMMEDIATE, typename Eol = lf_crlf_eol >
+      using file_input = read_input< P, Eol >;
 #endif
 
    }  // namespace TAOCPP_JSON_PEGTL_NAMESPACE