Fiddle with details.

include/tao/pegtl/analyze.hpp

@@ -152,7 +152,7 @@ namespace TAO_PEGTL_NAMESPACE
  {
  using Traits = analyze_traits< Name, typename Name::rule_t >;
 
- const auto [ i, b ] = entry.try_emplace( demangle< Name >(), Traits::type_v );
+ const auto [ i, b ] = entry.try_emplace( demangle< Name >(), Traits::enum_v );
  if( b ) {
  analyze_insert_impl( typename Traits::subs_t(), i->second.subs, entry );
  }

include/tao/pegtl/analyze_traits.hpp

@@ -17,31 +17,31 @@ namespace TAO_PEGTL_NAMESPACE
  struct analyze_any_traits
  {
  // Consumption-on-success is always true; assumes bounded repetition of conjunction of sub-rules.
- static constexpr internal::analyze_enum type_v = internal::analyze_enum::any;
+ static constexpr internal::analyze_enum enum_v = internal::analyze_enum::any;
  using subs_t = type_list< Rules... >;
  };
 
  template< typename... Rules >
  struct analyze_opt_traits
  {
  // Consumption-on-success not necessarily true; assumes bounded repetition of conjunction of sub-rules.
- static constexpr internal::analyze_enum type_v = internal::analyze_enum::opt;
+ static constexpr internal::analyze_enum enum_v = internal::analyze_enum::opt;
  using subs_t = type_list< Rules... >;
  };
 
  template< typename... Rules >
  struct analyze_seq_traits
  {
  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) conjunction of sub-rules.
- static constexpr internal::analyze_enum type_v = internal::analyze_enum::seq;
+ static constexpr internal::analyze_enum enum_v = internal::analyze_enum::seq;
  using subs_t = type_list< Rules... >;
  };
 
  template< typename... Rules >
  struct analyze_sor_traits
  {
  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) disjunction of sub-rules.
- static constexpr internal::analyze_enum type_v = internal::analyze_enum::sor;
+ static constexpr internal::analyze_enum enum_v = internal::analyze_enum::sor;
  using subs_t = type_list< Rules... >;
  };
 

include/tao/pegtl/ascii.hpp

@@ -94,7 +94,7 @@ namespace TAO_PEGTL_NAMESPACE
  struct lf_crlf : ascii::lf_crlf { using eol_lazy_peek = internal::peek_char; };
  struct cr_lf_crlf : ascii::cr_lf_crlf { using eol_lazy_peek = internal::peek_char; };
  // clang-format on
- } // namespace rule
+ } // namespace lazy
 
  } // namespace ascii
 

include/tao/pegtl/buffer/discard.hpp

@@ -23,6 +23,6 @@ namespace TAO_PEGTL_NAMESPACE
  }
  };
 
-} // namespace TAO_PEGTL_NAMESPACE::internal
+} // namespace TAO_PEGTL_NAMESPACE
 
 #endif

include/tao/pegtl/buffer/require.hpp

@@ -32,6 +32,6 @@ namespace TAO_PEGTL_NAMESPACE
  : internal::success
  {};
 
-} // namespace TAO_PEGTL_NAMESPACE::internal
+} // namespace TAO_PEGTL_NAMESPACE
 
 #endif

include/tao/pegtl/contrib/dispatch.hpp

@@ -11,9 +11,9 @@
 
 #include "../apply_mode.hpp"
 #include "../config.hpp"
+#include "../match.hpp"
 #include "../normal.hpp"
 #include "../nothing.hpp"
-#include "../match.hpp"
 #include "../rewind_mode.hpp"
 
 #include "../internal/dependent_false.hpp"

include/tao/pegtl/contrib/trace.hpp

@@ -9,9 +9,9 @@
 #include <type_traits>
 
 #include "../config.hpp"
-#include "../parse.hpp"
 #include "../normal.hpp"
 #include "../nothing.hpp"
+#include "../parse.hpp"
 
 #include "../control/state_control.hpp"
 

include/tao/pegtl/internal/analyze_traits.hpp

@@ -27,7 +27,7 @@ namespace TAO_PEGTL_NAMESPACE
 
  template< typename Name, typename... Actions >
  struct analyze_traits< Name, internal::apply< Actions... > >
- : analyze_opt_traits<> 
+ : analyze_opt_traits<>
  {};
 
  template< typename Name, typename... Actions >

include/tao/pegtl/internal/choose_lazy_traits.hpp

@@ -23,7 +23,7 @@ namespace TAO_PEGTL_NAMESPACE::internal
  {
  static_assert( !std::is_same_v< Eol, void > );
 
- if constexpr( get_eol_rule_char_v< Eol > ) {
+ if constexpr( int( get_eol_rule_char_v< Eol > ) != 0 ) {
  char_scan_traits< Eol >::scan( pos, in );
  }
  else if constexpr( has_eol_char_rule< Eol > ) {

include/tao/pegtl/internal/input_with_funcs.hpp

@@ -6,6 +6,7 @@
 #define TAO_PEGTL_INTERNAL_INPUT_WITH_FUNCS_HPP
 
 #include <cstddef>
+#include <cstdint>
 #include <string>
 #include <string_view>
 #include <vector>

include/tao/pegtl/internal/inputs.hpp

@@ -41,12 +41,12 @@ namespace TAO_PEGTL_NAMESPACE::internal
  template< typename Eol, typename Input >
  using base_short = input_with_fakes< input_with_funcs< input_with_lines< Eol, Input > > >;
 
- template< typename Eol, typename Input >
- using text_short = input_double_path< text_input_with_source< Eol, std::filesystem::path, std::filesystem::path, Input > >;
-
  template< typename Input >
  using path_short = input_double_path< input_with_source< std::filesystem::path, std::filesystem::path, Input > >;
 
+ template< typename Eol, typename Input >
+ using text_short = input_double_path< text_input_with_source< Eol, std::filesystem::path, std::filesystem::path, Input > >;
+
  template< typename Eol, typename Data >
  using base_alias = base_short< Eol, view_input< Data > >;
 

include/tao/pegtl/internal/integer_size.hpp

@@ -32,7 +32,7 @@ namespace TAO_PEGTL_NAMESPACE::internal
  }
  }
 
- template< typename Type, typename Input>
+ template< typename Type, typename Input >
  [[nodiscard]] constexpr std::size_t integer_input_size() noexcept
  {
  using Data = typename Input::data_t;

include/tao/pegtl/internal/utf32_to_utf8.hpp

@@ -65,7 +65,7 @@ namespace TAO_PEGTL_NAMESPACE::internal
  using type = String<>;
  };
 
- template< char32_t...  Cs >
+ template< char32_t... Cs >
  using utf32_to_utf8_t = typename utf32_to_utf8_list< ascii_string, Cs... >::type;
 
 } // namespace TAO_PEGTL_NAMESPACE::internal

include/tao/pegtl/internal/utf_rules.ipp

@@ -72,7 +72,7 @@ namespace TAO_PEGTL_NAMESPACE::TAO_PEGTL_UTF_NAME
  struct ps : TAO_PEGTL_UTF_NAME::ps { using eol_lazy_peek = TAO_PEGTL_UTF_PEEK; };
  struct eolu : TAO_PEGTL_UTF_NAME::eolu { using eol_lazy_peek = TAO_PEGTL_UTF_PEEK; };
  // clang-format on
- } // namespace rule
+ } // namespace lazy
 
 } // namespace TAO_PEGTL_NAMESPACE::TAO_PEGTL_UTF_NAME
 

include/tao/pegtl/internal/utf_string.hpp

@@ -35,7 +35,7 @@ namespace TAO_PEGTL_NAMESPACE::internal
  };
 
  template< typename Peek, char32_t... Cs >
- using utf_string_t = typename utf_string< Peek, Cs...>::type;
+ using utf_string_t = typename utf_string< Peek, Cs... >::type;
 
 } // namespace TAO_PEGTL_NAMESPACE::internal
 

include/tao/pegtl/parse_error.hpp

@@ -43,18 +43,19 @@ namespace TAO_PEGTL_NAMESPACE
  const position_t m_position;
  };
 
+ template< typename Position >
+ parse_error( const std::string&, Position ) -> parse_error< std::decay_t< Position > >;
+
  template< typename Object >
  [[noreturn]] void throw_parse_error( const std::string& msg, const Object& obj )
  {
- auto pos = internal::extract_position( obj );
- throw parse_error< std::decay_t< decltype( pos ) > >( msg, std::move( pos ) );
+ throw parse_error( msg, internal::extract_position( obj ) );
  }
 
  template< typename Object >
  [[noreturn]] void throw_with_nested_parse_error( const std::string& msg, const Object& obj )
  {
- auto pos = internal::extract_position( obj );
- std::throw_with_nested( parse_error< std::decay_t< decltype( pos ) > >( msg, std::move( pos ) ) );
+ std::throw_with_nested( parse_error( msg, internal::extract_position( obj ) ) );
  }
 
 } // namespace TAO_PEGTL_NAMESPACE

include/tao/pegtl/position_with_source.hpp

@@ -18,6 +18,12 @@ namespace TAO_PEGTL_NAMESPACE
  {
  Source source;
 
+ position_with_source( position_with_source&& ) = default;
+ position_with_source( const position_with_source& ) = default;
+
+ position_with_source& operator=( position_with_source&& ) = default;
+ position_with_source& operator=( const position_with_source& ) = default;
+
  template< typename S, typename... Ps >
  explicit position_with_source( S&& s, Ps&&... ps )
  : Position( std::forward< Ps >( ps )... ),

include/tao/pegtl/text_position_with_source.hpp

@@ -2,8 +2,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TAO_PEGTL_INTERNAL_TEXT_POSITION_WITH_SOURCE_HPP
-#define TAO_PEGTL_INTERNAL_TEXT_POSITION_WITH_SOURCE_HPP
+#ifndef TAO_PEGTL_TEXT_POSITION_WITH_SOURCE_HPP
+#define TAO_PEGTL_TEXT_POSITION_WITH_SOURCE_HPP
 
 #include <filesystem>
 #include <string>

src/test/pegtl/action_match_lazy.cpp

@@ -123,7 +123,7 @@ namespace TAO_PEGTL_NAMESPACE
  void unit_test()
  {
  state_one state;
- text_view_input< lazy::lf >in( "aaa" );
+ text_view_input< lazy::lf > in( "aaa" );
  global_start = in.current();
  const bool parse_result = parse< grammar_one_a, action_one_a >( in, state );
  TAO_PEGTL_TEST_ASSERT( parse_result );

src/test/pegtl/action_match_text.cpp

@@ -129,7 +129,7 @@ namespace TAO_PEGTL_NAMESPACE
  void unit_test()
  {
  state_one state;
- text_view_input< scan::lf >in( "aaa" );
+ text_view_input< scan::lf > in( "aaa" );
  global_start = in.current();
  const bool parse_result = parse< grammar_one_a, action_one_a >( in, state );
  TAO_PEGTL_TEST_ASSERT( parse_result );

src/test/pegtl/internal_get_eol_rule_char.cpp

@@ -5,8 +5,8 @@
 #include <type_traits>
 
 #include <tao/pegtl/ascii.hpp>
-#include <tao/pegtl/utf8.hpp>
 #include <tao/pegtl/utf32.hpp>
+#include <tao/pegtl/utf8.hpp>
 
 #include <tao/pegtl/internal/get_eol_rule_char.hpp>
 

src/test/pegtl/internal_lazy_scan_traits.cpp

@@ -9,6 +9,7 @@
 #include "test_utility.hpp"
 
 #include <tao/pegtl/text_position.hpp>
+
 #include <tao/pegtl/internal/data_and_size.hpp>
 #include <tao/pegtl/internal/dependent_false.hpp>
 #include <tao/pegtl/internal/lazy_scan_traits.hpp>

src/test/pegtl/internal_text_scan_traits.cpp

@@ -9,6 +9,7 @@
 #include "test_utility.hpp"
 
 #include <tao/pegtl/text_position.hpp>
+
 #include <tao/pegtl/internal/text_scan_traits.hpp>
 
 namespace TAO_PEGTL_NAMESPACE

src/test/pegtl/test_endian.hpp

@@ -16,6 +16,17 @@ namespace TAO_PEGTL_NAMESPACE::test
  // the one in tao/pegtl/include/endian.hpp etc. for the tests to be useful...
  // TODO: When can we finally switch to the C++20 and C++23 endian facilities?
 
+ [[nodiscard]] inline bool is_be() noexcept
+ {
+ union {
+ std::uint8_t a[ 2 ];
+ std::uint16_t i;
+ } u;
+ static_assert( sizeof( u ) == 2 );
+ u.i = 0x1af3;
+ return u.a[ 0 ] == 0x1a;
+ }
+
  [[nodiscard]] inline std::uint16_t b_swap( const std::uint16_t value ) noexcept
  {
  return ( ( value & 0x00ff ) << 8 ) | ( ( value & 0xff00 ) >> 8 );
@@ -28,31 +39,31 @@ namespace TAO_PEGTL_NAMESPACE::test
 
  [[nodiscard]] inline std::uint16_t h_to_be( const std::uint16_t value ) noexcept
  {
- if( htons( value ) == value ) {
+ if( is_be() ) {
  return value;
  }
  return b_swap( value );
  }
 
  [[nodiscard]] inline std::uint16_t h_to_le( const std::uint16_t value ) noexcept
  {
- if( htons( value ) == value ) {
+ if( is_be() ) {
  return b_swap( value );
  }
  return value;
  }
 
  [[nodiscard]] inline std::uint32_t h_to_be( const std::uint32_t value ) noexcept
  {
- if( htonl( value ) == value ) {
+ if( is_be() ) {
  return value;
  }
  return b_swap( value );
  }
 
  [[nodiscard]] inline std::uint32_t h_to_le( const std::uint32_t value ) noexcept
  {
- if( htonl( value ) == value ) {
+ if( is_be() ) {
  return b_swap( value );
  }
  return value;

src/test/pegtl/test_result.cpp

@@ -5,6 +5,7 @@
 #include <sstream>
 
 #include "test.hpp"
+
 #include "result_type.hpp"
 
 namespace TAO_PEGTL_NAMESPACE
@@ -15,18 +16,15 @@ namespace TAO_PEGTL_NAMESPACE
  std::ostringstream oss;
  oss << result_type::success;
  TAO_PEGTL_TEST_ASSERT( oss.str() == "success" );
- }
- {
+ } {
  std::ostringstream oss;
  oss << result_type::local_failure;
  TAO_PEGTL_TEST_ASSERT( oss.str() == "local_failure" );
- }
- {
+ } {
  std::ostringstream oss;
  oss << result_type::global_failure;
  TAO_PEGTL_TEST_ASSERT( oss.str() == "global_failure" );
- }
- {
+ } {
  std::ostringstream oss;
  oss << static_cast< result_type >( 1764 );
  TAO_PEGTL_TEST_ASSERT( oss.str() == "1764" );