Update embedded PEGTL

Author: d-frey

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

@@ -49,101 +49,46 @@ namespace tao_json_pegtl
             if ( j != m_cache.end() ) {
                return j->second;
             }
-            const auto g = make_insert_guard( m_stack, start->first );
-
-            if ( g ) {
+            if ( const auto g = make_insert_guard( m_stack, start->first ) ) {
                switch ( start->second.type ) {
-                  case rule_type::PLUS:
-                  {
+                  case rule_type::ANY: {
                      bool a = false;
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        a |= work( find( start->second.rules[ i ] ), accum || a );
-                     }
-                     if ( ! a ) {
-                        ++m_problems;
-                        if ( m_verbose ) {
-                           std::cout << "problem: rules without progress detected in rule of type plus " << start->first << std::endl;
-                        }
+                     for ( const auto & r : start->second.rules ) {
+                        a |= work( find( r ), accum || a );
                      }
-                     return m_cache[ start->first ] = a;
+                     return m_cache[ start->first ] = true;
                   }
-                  case rule_type::STAR:
-                  {
+                  case rule_type::OPT: {
                      bool a = false;
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        a |= work( find( start->second.rules[ i ] ), accum || a );
-                     }
-                     if ( ! a ) {
-                        ++m_problems;
-                        if ( m_verbose ) {
-                           std::cout << "problem: rules without progress detected in rule of type star " << start->first << std::endl;
-                        }
+                     for ( const auto & r : start->second.rules ) {
+                        a |= work( find( r ), accum || a );
                      }
                      return m_cache[ start->first ] = false;
                   }
-                  case rule_type::SEQ:
-                  {
+                  case rule_type::SEQ: {
                      bool a = false;
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        a |= work( find( start->second.rules[ i ] ), accum || a );
+                     for ( const auto & r : start->second.rules ) {
+                        a |= work( find( r ), accum || a );
                      }
                      return m_cache[ start->first ] = a;
                   }
-                  case rule_type::SOR:
-                  {
+                  case rule_type::SOR: {
                      bool a = true;
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        a &= work( find( start->second.rules[ i ] ), accum );
+                     for ( const auto & r : start->second.rules ) {
+                        a &= work( find( r ), accum );
                      }
                      return m_cache[ start->first ] = a;
                   }
-                  case rule_type::ANY:
-                  {
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        work( find( start->second.rules[ i ] ), accum );
-                     }
-                     return m_cache[ start->first ] = true;
-                  }
-                  case rule_type::OPT:
-                  {
-                     for ( std::size_t i = 0; i < start->second.rules.size(); ++i ) {
-                        work( find( start->second.rules[ i ] ), accum );
-                     }
-                     return m_cache[ start->first ] = false;
-                  }
-                  case rule_type::UNTIL:
-                  {
-                     bool a = false;
-                     for ( std::size_t i = 1; i < start->second.rules.size(); ++i ) {
-                        a |= work( find( start->second.rules[ i ] ), accum || a );
-                     }
-                     if ( ! a ) {
-                        ++m_problems;
-                        if ( m_verbose ) {
-                           std::cout << "problem: rules without progress detected in until " << start->first << std::endl;
-                        }
-                     }
-                     return m_cache[ start->first ] = work( find( start->second.rules[ 0 ] ), accum );
-                  }
-                  case rule_type::IF:
-                  {
-                     assert( start->second.rules.size() == 3 );
-                     const bool c = work( find( start->second.rules[ 0 ] ), accum );  // Cond
-                     const bool t = work( find( start->second.rules[ 1 ] ), accum || c );  // Rule
-                     const bool e = work( find( start->second.rules[ 2 ] ), accum );  // Else
-                     return m_cache[ start->first ] = ( c || t ) && e;
-                  }
                }
                assert( false );  // LCOV_EXCL_LINE
             }
             if ( ! accum ) {
                ++m_problems;
                if ( m_verbose ) {
-                  std::cout << "problem: cycle without progress detected at class " << start->first << std::endl;
+                  std::cout << "problem: cycle without progress detected at rule class " << start->first << std::endl;
                }
-               return m_cache[ start->first ] = false;
             }
-            return m_cache[ start->first ] = accum;  // Cycle with progress.
+            return m_cache[ start->first ] = accum;
          }
       };
 

include/tao/json/external/pegtl/analysis/rule_type.hh

@@ -10,17 +10,10 @@ namespace tao_json_pegtl
    {
       enum class rule_type : char
       {
-         ANY,    // "Success implies consumption" is true; assumes bounded repetition of conjunction of sub-rules.
-         OPT,    // "Success implies consumption" is false; assumes bounded repetition of conjunction of sub-rules.
-
-         SEQ,    // Consumption on success depends on non-zero bounded repetition of conjunction of sub-rules.
-         SOR,    // Consumption on success depends on non-zero bounded repetition of disjunction of sub-rules.
-
-         PLUS,   // Similar to seq but for non-zero unbounded repetition of conjunction of sub-rules.
-         STAR,   // Similar to seq but for optional unbounded repetition of conjunction of sub-rules.
-
-         UNTIL,  // Specific handling of until<> rules.
-         IF      // Specific handling of if_then_else<> rule.
+         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.
       };
 
    } // analysis

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2014-2016 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
 
 #ifndef TAOCPP_JSON_EMBEDDED_PEGTL_ASCII_HH
@@ -16,7 +16,7 @@ namespace tao_json_pegtl
       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::one< internal::result_on_found::SUCCESS, internal::peek_char, '\n' > {};
+      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', '_' > {};

include/tao/json/external/pegtl/contrib/http.hh

@@ -54,7 +54,7 @@ namespace tao_json_pegtl
       struct status_code : rep< 3, DIGIT > {};
       struct reason_phrase : star< sor< VCHAR, obs_text, WSP > > {};
 
-      struct HTTP_version : if_must< pegtl_string_t( "HTTP/" ), DIGIT, one< '.' >, DIGIT > {};
+      struct HTTP_version : if_must< tao_json_pegtl_string_t( "HTTP/" ), DIGIT, one< '.' >, DIGIT > {};
 
       struct request_line : if_must< method, SP, request_target, SP, HTTP_version, CRLF > {};
       struct status_line : if_must< HTTP_version, SP, status_code, SP, reason_phrase, CRLF > {};
@@ -78,17 +78,17 @@ namespace tao_json_pegtl
 
       struct transfer_parameter : seq< token, BWS, one< '=' >, BWS, sor< token, quoted_string > > {};
       struct transfer_extension : seq< token, star< OWS, one< ';' >, OWS, transfer_parameter > > {};
-      struct transfer_coding : sor< pegtl_istring_t( "chunked" ),
-                                    pegtl_istring_t( "compress" ),
-                                    pegtl_istring_t( "deflate" ),
-                                    pegtl_istring_t( "gzip" ),
+      struct transfer_coding : sor< tao_json_pegtl_istring_t( "chunked" ),
+                                    tao_json_pegtl_istring_t( "compress" ),
+                                    tao_json_pegtl_istring_t( "deflate" ),
+                                    tao_json_pegtl_istring_t( "gzip" ),
                                     transfer_extension > {};
 
       struct rank : sor< seq< one< '0' >, opt< one< '.' >, rep_opt< 3, DIGIT > > >,
                          seq< one< '1' >, opt< one< '.' >, rep_opt< 3, one< '0' > > > > > {};
 
       struct t_ranking : seq< OWS, one< ';' >, OWS, one< 'q', 'Q' >, one< '=' >, rank > {};
-      struct t_codings : sor< pegtl_istring_t( "trailers" ), seq< transfer_coding, opt< t_ranking > > > {};
+      struct t_codings : sor< tao_json_pegtl_istring_t( "trailers" ), seq< transfer_coding, opt< t_ranking > > > {};
 
       struct TE : opt< sor< one< ',' >, t_codings >, star< OWS, one< ',' >, opt< OWS, t_codings > > > {};
 
@@ -116,8 +116,8 @@ namespace tao_json_pegtl
 
       struct Via : make_comma_list< seq< received_protocol, RWS, received_by, opt< RWS, comment > > > {};
 
-      struct http_URI : if_must< pegtl_istring_t( "http://" ), uri::authority, uri::path_abempty, uri::opt_query, uri::opt_fragment > {};
-      struct https_URI : if_must< pegtl_istring_t( "https://" ), uri::authority, uri::path_abempty, uri::opt_query, uri::opt_fragment > {};
+      struct http_URI : if_must< tao_json_pegtl_istring_t( "http://" ), uri::authority, uri::path_abempty, uri::opt_query, uri::opt_fragment > {};
+      struct https_URI : if_must< tao_json_pegtl_istring_t( "https://" ), uri::authority, uri::path_abempty, uri::opt_query, uri::opt_fragment > {};
 
       struct partial_URI : seq< uri::relative_part, uri::opt_query > {};
 

include/tao/json/external/pegtl/contrib/json.hh

@@ -26,9 +26,9 @@ namespace tao_json_pegtl
       struct name_separator : pad< one< ':' >, ws > {};
       struct value_separator : padr< one< ',' > > {};
 
-      struct false_ : pegtl_string_t( "false" ) {};
-      struct null : pegtl_string_t( "null" ) {};
-      struct true_ : pegtl_string_t( "true" ) {};
+      struct false_ : tao_json_pegtl_string_t( "false" ) {};
+      struct null : tao_json_pegtl_string_t( "null" ) {};
+      struct true_ : tao_json_pegtl_string_t( "true" ) {};
 
       struct digits : plus< abnf::DIGIT > {};
       struct exp : seq< one< 'e', 'E' >, opt< one< '-', '+'> >, must< digits > > {};

include/tao/json/external/pegtl/input.hh

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2014-2016 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
 
 #ifndef TAOCPP_JSON_EMBEDDED_PEGTL_INPUT_HH
@@ -91,13 +91,11 @@ namespace tao_json_pegtl
          m_data.column += count;
       }
 
-      bool bump_if()
+      void bump_next_line( const std::size_t count = 1 )
       {
-         if ( ! empty() ) {
-            bump_unsafe();
-            return true;
-         }
-         return false;
+         ++m_data.line;
+         m_data.begin += count;
+         m_data.column = 0;
       }
 
       internal::input_mark mark()

include/tao/json/external/pegtl/input_error.hh

@@ -1,11 +1,12 @@
-// Copyright (c) 2014-2015 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2014-2016 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
 
 #ifndef TAOCPP_JSON_EMBEDDED_PEGTL_INPUT_ERROR_HH
 #define TAOCPP_JSON_EMBEDDED_PEGTL_INPUT_ERROR_HH
 
 #include <sstream>
 #include <stdexcept>
+#include <cerrno>
 
 namespace tao_json_pegtl
 {

include/tao/json/external/pegtl/internal/any.hh

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2014-2016 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
 
 #ifndef TAOCPP_JSON_EMBEDDED_PEGTL_INTERNAL_ANY_HH
@@ -26,7 +26,11 @@ namespace tao_json_pegtl
          template< typename Input >
          static bool match( Input & in )
          {
-            return in.bump_if();
+            if ( ! in.empty() ) {
+               in.bump();
+               return true;
+            }
+            return false;
          }
       };
 

include/tao/json/external/pegtl/internal/eol.hh

@@ -0,0 +1,51 @@
+// Copyright (c) 2016 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
+
+#ifndef TAOCPP_JSON_EMBEDDED_PEGTL_INTERNAL_EOL_HH
+#define TAOCPP_JSON_EMBEDDED_PEGTL_INTERNAL_EOL_HH
+
+#include "skip_control.hh"
+
+#include "../analysis/generic.hh"
+
+namespace tao_json_pegtl
+{
+   namespace internal
+   {
+      struct eol
+      {
+         using analyze_t = analysis::generic< analysis::rule_type::ANY >;
+
+         template< typename Input >
+         static bool match( Input & in )
+         {
+            if ( const auto s = in.size() ) {
+               return match_impl( in, s );
+            }
+            return false;
+         }
+
+         template< typename Input >
+         static bool match_impl( Input & in, const std::size_t s )
+         {
+            const auto a = in.peek_char();
+            if ( a == '\n' ) {
+               in.bump_next_line();
+               return true;
+            }
+            if ( ( a == '\r' ) && ( s > 1 ) && ( in.peek_char( 1 ) == '\n' ) ) {
+               in.bump_next_line( 2 );
+               return true;
+            }
+            return false;
+         }
+      };
+
+      template<>
+      struct skip_control< eol > : std::true_type {};
+
+   } // internal
+
+} // tao_json_pegtl
+
+#endif

include/tao/json/external/pegtl/internal/eolf.hh

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2014-2016 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/ColinH/PEGTL/
 
 #ifndef TAOCPP_JSON_EMBEDDED_PEGTL_INTERNAL_EOLF_HH
@@ -8,6 +8,8 @@
 
 #include "../analysis/generic.hh"
 
+#include "eol.hh"
+
 namespace tao_json_pegtl
 {
    namespace internal
@@ -19,14 +21,10 @@ namespace tao_json_pegtl
          template< typename Input >
          static bool match( Input & in )
          {
-            if ( in.empty() ) {
-               return true;
-            }
-            else if ( in.peek_char() == '\n' ) {
-               in.bump();
-               return true;
+            if ( const auto s = in.size() ) {
+               return eol::match_impl( in, s );
             }
-            return false;
+            return true;
          }
       };