Update PEGTL.

Author: ColinH

include/tao/json/external/pegtl.hpp

@@ -13,12 +13,21 @@
 #include "pegtl/utf32.hpp"
 #include "pegtl/utf8.hpp"
 
+#include "pegtl/parse.hpp"
+
+#include "pegtl/buffer_input.hpp"
+#include "pegtl/file_input.hpp"
+#include "pegtl/memory_input.hpp"
+#include "pegtl/read_input.hpp"
+#include "pegtl/stream_input.hpp"
+#include "pegtl/string_input.hpp"
+
 // The following files can be included whenever needed; they
-// are not included by default because they include <iostream>.
-// #include "pegtl/trace.hpp"
-// #include "pegtl/analyze.hpp"
+// are not included by default because they include a stream header
+// like <iostream> or <sstream>.
 
-#include "pegtl/file_parser.hpp"
-#include "pegtl/string_parser.hpp"
+// #include "pegtl/argv_input.hpp"
+// #include "pegtl/analyze.hpp"
+// #include "pegtl/tracer.hpp"
 
 #endif

include/tao/json/external/pegtl/analysis/analyze_cycles.hpp

@@ -26,7 +26,7 @@ namespace tao
          class analyze_cycles_impl
          {
          protected:
-            explicit analyze_cycles_impl( const bool verbose )
+            explicit analyze_cycles_impl( const bool verbose ) noexcept
                : m_verbose( verbose ),
                  m_problems( 0 )
             {
@@ -39,7 +39,7 @@ namespace tao
             std::map< std::string, bool > m_cache;
             std::map< std::string, bool > m_results;
 
-            const std::map< std::string, rule_info >::const_iterator find( const std::string& name ) const
+            const std::map< std::string, rule_info >::const_iterator find( const std::string& name ) const noexcept
             {
                const auto iter = m_info.map.find( name );
                assert( iter != m_info.map.end() );
@@ -117,7 +117,7 @@ namespace tao
             }
 
             template< typename Rule >
-            bool consumes() const
+            bool consumes() const noexcept
             {
                const auto i = m_results.find( internal::demangle< Rule >() );
                assert( i != m_results.end() );

include/tao/json/external/pegtl/analysis/insert_guard.hpp

@@ -41,7 +41,7 @@ namespace tao
             insert_guard( const insert_guard& ) = delete;
             void operator=( const insert_guard& ) = delete;
 
-            explicit operator bool() const
+            explicit operator bool() const noexcept
             {
                return m_i.second;
             }

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

@@ -0,0 +1,65 @@
+// Copyright (c) 2017 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAOCPP_JSON_PEGTL_INCLUDE_ARGV_INPUT_HPP
+#define TAOCPP_JSON_PEGTL_INCLUDE_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
+{
+   namespace TAOCPP_JSON_PEGTL_NAMESPACE
+   {
+      namespace internal
+      {
+         inline std::string make_argv_source( const std::size_t argn )
+         {
+            std::ostringstream os;
+            os << "argv[" << argn << ']';
+            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 >
+      struct argv_input
+         : private internal::argv_holder,
+           public memory_input< Eol, P >
+      {
+         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 )
+         {
+         }
+
+         argv_input( char** argv, const std::size_t argn )
+            : argv_input( argv, argn, internal::make_argv_source( argn ) )
+         {
+         }
+      };
+
+   }  // namespace TAOCPP_JSON_PEGTL_NAMESPACE
+
+}  // namespace tao
+
+#endif

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

@@ -15,29 +15,30 @@ namespace tao
       inline namespace ascii
       {
          // clang-format off
-         struct alnum : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9' > {};
-         struct alpha : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z' > {};
+         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 eol : internal::eol {};
          struct eolf : internal::eolf {};
-         struct identifier_first : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '_' > {};
-         struct identifier_other : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9', '_' > {};
-         struct identifier : internal::seq< identifier_first, internal::star< identifier_other > > {};
-         template< char ... Cs > struct istring : internal::istring< 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 C, char... Cs > struct keyword : internal::seq< internal::string< C, 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... 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 ... > {};
+         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 ... > {};
+         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< 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... Cs > struct string : internal::string< Cs... > {};
          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' > {};

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

@@ -9,31 +9,32 @@
 #include <memory>
 
 #include "config.hpp"
-#include "count_data.hpp"
 #include "eol.hpp"
+#include "memory_input.hpp"
+#include "position.hpp"
+#include "tracking_mode.hpp"
+
 #include "internal/action_input.hpp"
 #include "internal/bump_impl.hpp"
-#include "internal/input_mark.hpp"
-#include "position_info.hpp"
+#include "internal/iterator.hpp"
+#include "internal/marker.hpp"
 
 namespace tao
 {
    namespace TAOCPP_JSON_PEGTL_NAMESPACE
    {
-      template< typename Eol >
-      class basic_memory_input;
-
-      template< typename Eol, typename Reader >
-      class basic_buffer_input
+      template< typename Reader, typename Eol = lf_crlf_eol >
+      class buffer_input
       {
       public:
-         using eol_t = Eol;
          using reader_t = Reader;
-         using action_t = internal::basic_action_input< Eol >;
-         using memory_t = basic_memory_input< Eol >;
+         using eol_t = Eol;
+
+         using memory_t = memory_input< Eol >;
+         using action_t = internal::action_input< Eol, tracking_mode::IMMEDIATE >;
 
          template< typename... As >
-         basic_buffer_input( const char* in_source, const std::size_t maximum, As&&... as )
+         buffer_input( const char* in_source, const std::size_t maximum, As&&... as )
             : m_reader( std::forward< As >( as )... ),
               m_maximum( maximum ),
               m_buffer( new char[ maximum ] ),
@@ -43,8 +44,14 @@ namespace tao
          {
          }
 
-         basic_buffer_input( const basic_buffer_input& ) = delete;
-         void operator=( const basic_buffer_input& ) = delete;
+         template< typename... As >
+         buffer_input( const std::string& in_source, As&&... as )
+            : buffer_input( in_source.c_str(), std::forward< As >( as )... )
+         {
+         }
+
+         buffer_input( const buffer_input& ) = delete;
+         void operator=( const buffer_input& ) = delete;
 
          bool empty()
          {
@@ -58,7 +65,7 @@ namespace tao
             return std::size_t( m_end - m_data.data );
          }
 
-         const char* begin() const
+         const char* begin() const noexcept
          {
             return m_data.data;
          }
@@ -69,52 +76,52 @@ namespace tao
             return m_end;
          }
 
-         std::size_t byte() const
+         std::size_t byte() const noexcept
          {
             return m_data.byte;
          }
 
-         std::size_t line() const
+         std::size_t line() const noexcept
          {
             return m_data.line;
          }
 
-         std::size_t byte_in_line() const
+         std::size_t byte_in_line() const noexcept
          {
             return m_data.byte_in_line;
          }
 
-         const char* source() const
+         const char* source() const noexcept
          {
             return m_source;
          }
 
-         char peek_char( const std::size_t offset = 0 ) const
+         char peek_char( const std::size_t offset = 0 ) const noexcept
          {
             return m_data.data[ offset ];
          }
 
-         unsigned char peek_byte( const std::size_t offset = 0 ) const
+         unsigned char peek_byte( const std::size_t offset = 0 ) const noexcept
          {
             return static_cast< unsigned char >( peek_char( offset ) );
          }
 
-         void bump( const std::size_t in_count = 1 )
+         void bump( const std::size_t in_count = 1 ) noexcept
          {
             internal::bump( m_data, in_count, Eol::ch );
          }
 
-         void bump_in_this_line( const std::size_t in_count = 1 )
+         void bump_in_this_line( const std::size_t in_count = 1 ) noexcept
          {
             internal::bump_in_this_line( m_data, in_count );
          }
 
-         void bump_to_next_line( const std::size_t in_count = 1 )
+         void bump_to_next_line( const std::size_t in_count = 1 ) noexcept
          {
             internal::bump_to_next_line( m_data, in_count );
          }
 
-         void discard()
+         void discard() noexcept
          {
             const auto s = m_end - m_data.data;
             std::memmove( m_buffer.get(), m_data.data, s );
@@ -137,17 +144,17 @@ namespace tao
          }
 
          template< rewind_mode M >
-         internal::input_mark< M > mark()
+         internal::marker< internal::iterator, M > mark() noexcept
          {
-            return internal::input_mark< M >( m_data );
+            return internal::marker< internal::iterator, M >( m_data );
          }
 
-         position_info position() const
+         TAOCPP_JSON_PEGTL_NAMESPACE::position position() const noexcept
          {
-            return position_info( m_data, m_source );
+            return TAOCPP_JSON_PEGTL_NAMESPACE::position( m_data, m_source );
          }
 
-         const count_data& count() const
+         const internal::iterator& iterator() const noexcept
          {
             return m_data;
          }
@@ -156,14 +163,11 @@ namespace tao
          Reader m_reader;
          std::size_t m_maximum;
          std::unique_ptr< char[] > m_buffer;
-         count_data m_data;
+         internal::iterator m_data;
          const char* m_end;
-         const char* m_source;
+         const char* const m_source;
       };
 
-      template< typename Reader >
-      using buffer_input = basic_buffer_input< lf_crlf_eol, Reader >;
-
    }  // namespace TAOCPP_JSON_PEGTL_NAMESPACE
 
 }  // namespace tao

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

@@ -18,7 +18,7 @@ namespace tao
          struct dummy_disabled_state
          {
             template< typename... Ts >
-            void success( Ts&&... )
+            void success( Ts&&... ) const noexcept
             {
             }
          };