Merge branch 'main' into peg2pegtl

Author: uilianries

.clang-tidy

@@ -35,6 +35,7 @@ Checks: >-
   -readability-identifier-length,
   -readability-magic-numbers,
   -readability-static-accessed-through-instance,
+  -llvm-header-guard,
 
 CheckOptions:
   - { key: readability-identifier-naming.ClassCase,     value: lower_case }

.github/workflows/clang-tidy.yml

@@ -15,12 +15,20 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
-    - run: sudo apt-get update -yq
+    - name: Install Dependencies
+      run: |
+        sudo apt-get -qq update -yq
+        sudo apt-get -qq install -y clang-tidy --no-install-recommends --no-install-suggests
 
-    - run: sudo apt-get install -yq clang-tidy
+    - name: Generate Compilation Database
+      run: cmake -S . -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
 
-    - run: find include/ -name '*.hpp' | grep -vF mmap_file_win32.hpp | grep -vF endian_win.hpp | xargs -I '{}' clang-tidy --quiet '{}' -- --std=c++17 -Iinclude
+    - name: Run clang-tidy on Header Files
+      continue-on-error: true
+      run: find include/ -type f \( -name "*.hpp" -a ! -name "endian_win.hpp" -a ! -name "mmap_file_win32.hpp" \) | xargs -P $(nproc) -I {} clang-tidy -quiet -p build {} -- -std=c++17 -Iinclude
 
-    - run: find src/ -name '*.cpp' | xargs -I '{}' clang-tidy --quiet '{}' -- --std=c++17 -Iinclude
+    - name: Run clang-tidy on tests and examples files
+      continue-on-error: true
+      run: find src/ -type f -name "*.cpp" | xargs -P $(nproc) -I {} clang-tidy -quiet -p build {} -- -std=c++17 -Iinclude

include/tao/pegtl/internal/resize_uninitialized.hpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2023 Dr. Colin Hirsch and Daniel Frey
+// Copyright (c) 2021-2025 Daniel Frey and Dr. Colin Hirsch
 // 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)
 
@@ -7,111 +7,169 @@
 
 #include <cstddef>
 #include <string>
-
-#include "../config.hpp"
+#include <vector>
 
 namespace TAO_PEGTL_NAMESPACE::internal
 {
-   // the below uses a hack to call private member functions of a class, described here:
+   // This uses a hack to call private member functions of a class, described here:
    // https://github.com/facebook/folly/blob/master/folly/memory/UninitializedMemoryHacks.h
 
    namespace  // NOLINT(google-build-namespaces)
    {
-      // declare some functions...
-      void resize_uninitialized_proxy( std::string& v, const std::size_t n );
-      void resize_uninitialized_proxy( std::basic_string< unsigned char >& v, const std::size_t n );
-      void resize_uninitialized_proxy( std::basic_string< std::byte >& v, const std::size_t n );
+      struct odr_helper;
+
+      void resize_uninitialized_proxy( std::string& v, const std::size_t n ) noexcept;
 
 #if defined( _LIBCPP_STRING )
 
-      // ...create a proxy to generate the actual implementation of the above function...
-      template< typename T, void ( T::*F )( std::size_t ) >
-      struct proxy
+      // Create a proxy to generate the actual implementation of the above function...
+
+      template< typename T, auto F >
+      struct string_proxy
       {
          // ...define the function declared above...
-         friend void resize_uninitialized_proxy( T& v, const std::size_t n )
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
          {
             ( v.*F )( n );  // v.__set_size( n );
             v[ v.size() ] = typename T::value_type( 0 );
          }
       };
 
-      // ...and here's the actual "trick": an explicit template instantiation skips the access checks,
+      // ...the actual "trick": an explicit template instantiation skips the access checks,
       // so you can reference private members and forward them to the above proxy!
-      template struct proxy< std::string, &std::string::__set_size >;
-      template struct proxy< std::basic_string< unsigned char >, &std::basic_string< unsigned char >::__set_size >;
-      template struct proxy< std::basic_string< std::byte >, &std::basic_string< std::byte >::__set_size >;
 
-#elif defined( _GLIBCXX_STRING ) && _GLIBCXX_USE_CXX11_ABI
+      template struct string_proxy< std::string, &std::string::__set_size >;
 
-      template< typename T, void ( T::*F )( std::size_t ) >
-      struct proxy
+#elif defined( _GLIBCXX_STRING ) && _GLIBCXX_USE_CXX11_ABI  // NOLINT(misc-include-cleaner)
+
+      template< typename T, auto F >
+      struct string_proxy
       {
-         friend void resize_uninitialized_proxy( T& v, const std::size_t n )
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
          {
             ( v.*F )( n );  // v._M_set_length( n );
          }
       };
 
-      template struct proxy< std::string, &std::string::_M_set_length >;
-      template struct proxy< std::basic_string< unsigned char >, &std::basic_string< unsigned char >::_M_set_length >;
-      template struct proxy< std::basic_string< std::byte >, &std::basic_string< std::byte >::_M_set_length >;
+      template struct string_proxy< std::string, &std::string::_M_set_length >;
 
 #elif defined( _GLIBCXX_STRING )
 
-      template< typename T,
-                typename R,
-                R* ( T::*F )() const >
-      struct proxy
+      template< typename T, auto F >
+      struct string_proxy
       {
-         friend void resize_uninitialized_proxy( T& v, const std::size_t n )
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
          {
             // v._M_rep()->_M_set_length_and_sharable( n );
             ( v.*F )()->_M_set_length_and_sharable( n );
          }
       };
 
-      template struct proxy< std::string,
-                             std::string::_Rep,
-                             &std::string::_M_rep >;
+      template struct string_proxy< std::string, &std::string::_M_rep >;
+
+#elif defined( _MSC_VER )
+
+      template< typename T, auto F >
+      struct string_proxy
+      {
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
+         {
+            ( v.*F )( n );  // v._Eos( n );
+         }
+      };
 
-      template struct proxy< std::basic_string< unsigned char >,
-                             std::basic_string< unsigned char >::_Rep,
-                             &std::basic_string< unsigned char >::_M_rep >;
+      template struct string_proxy< std::string, &std::string::_Eos >;
+
+#else
+#error "No implementation for resize_uninitialized for std::string available on this platform."
+#endif
+
+#if defined( _LIBCPP_VECTOR )
+
+      void resize_uninitialized_proxy( std::vector< std::byte >& v, const std::size_t n ) noexcept;
+
+      template< typename T, auto M >
+      struct vector_proxy
+      {
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
+         {
+            // v.__end_ = v.data() + n;
+            v.*M = v.data() + n;
+
+#ifndef _LIBCPP_HAS_NO_ASAN
+            __sanitizer_annotate_contiguous_container( v.data(),
+                                                       v.data() + v.capacity(),
+                                                       v.data() + v.size(),
+                                                       v.data() + n );
+#endif
+         }
+      };
 
-      template struct proxy< std::basic_string< std::byte >,
-                             std::basic_string< std::byte >::_Rep,
-                             &std::basic_string< std::byte >::_M_rep >;
+      template struct vector_proxy< std::vector< std::byte >, &std::vector< std::byte >::__end_ >;
 
 #elif defined( _MSC_VER )
 
-      template< typename T, void ( T::*F )( std::size_t ) >
-      struct proxy
+      void resize_uninitialized_proxy( std::vector< std::byte >& v, const std::size_t n ) noexcept;
+
+      template< typename T, auto Mypair, auto Myval2, auto Mylast >
+      struct vector_proxy
       {
-         friend void resize_uninitialized_proxy( T& v, const std::size_t n )
+         friend void resize_uninitialized_proxy( T& v, const std::size_t n ) noexcept
          {
-            ( v.*F )( n );  // v._Eos( n );
+            // v._Mypair._Myval2._Mylast = v.data() + n;
+            v.*Mypair.*Myval2.*Mylast = v.data() + n;
          }
       };
 
-      template struct proxy< std::string, &std::string::_Eos >;
-      template struct proxy< std::basic_string< unsigned char >, &std::basic_string< unsigned char >::_Eos >;
-      template struct proxy< std::basic_string< std::byte >, &std::basic_string< std::byte >::_Eos >;
+      template struct vector_proxy< std::vector< std::byte >,
+                                    &std::vector< std::byte >::_Mypair,
+                                    &decltype( std::declval< std::vector< std::byte > >()._Mypair )::_Myval2,
+                                    &decltype( std::declval< std::vector< std::byte > >()._Mypair._Myval2 )::_Mylast >;
 
 #else
-#error "No implementation for resize_uninitialized available."
+
+      // generic version
+
+      struct no_init_byte
+      {
+         std::byte b;
+         no_init_byte() noexcept {}  // NOLINT(modernize-use-equals-default)
+      };
+
+      static_assert( sizeof( std::vector< std::byte > ) == sizeof( std::vector< no_init_byte > ) );
+      static_assert( alignof( std::vector< std::byte > ) == alignof( std::vector< no_init_byte > ) );
+
+      inline void resize_uninitialized_proxy( std::vector< std::byte >& v, const std::size_t n ) noexcept
+      {
+         // undefined behaviour?
+         reinterpret_cast< std::vector< no_init_byte >& >( v ).resize( n );
+      }
+
 #endif
 
    }  // namespace
 
-   template< typename T >
-   void resize_uninitialized( std::basic_string< T >& v, const std::size_t n )
+   template< typename = odr_helper >
+   void resize_uninitialized( std::string& v, const std::size_t n )
+   {
+      if( n <= v.size() ) {
+         v.resize( n );
+      }
+      else {
+         if( n > v.capacity() ) {
+            v.reserve( n );
+         }
+         internal::resize_uninitialized_proxy( v, n );
+      }
+   }
+
+   template< typename = odr_helper >
+   void resize_uninitialized( std::vector< std::byte >& v, const std::size_t n )
    {
       if( n <= v.size() ) {
          v.resize( n );
       }
       else {
-         // careful not to call reserve() unless necessary, as it causes shrink_to_fit() on many platforms
          if( n > v.capacity() ) {
             v.reserve( n );
          }