passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/random/xoshiro.hpp

@@ -0,0 +1,488 @@
+/*
+ * Copyright Matt Borland 2022 - 2025.
+ * Distributed under the Boost Software License, Version 1.0. (See
+        * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See http://www.boost.org for most recent version including documentation.
+ *
+ * $Id$
+ */
+
+#ifndef BOOST_RANDOM_XOSHIRO_HPP
+#define BOOST_RANDOM_XOSHIRO_HPP
+
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/xoshiro_base.hpp>
+#include <boost/core/bit.hpp>
+#include <array>
+#include <cstdint>
+
+namespace boost {
+namespace random {
+
+/**
+ * This is xoshiro256++ 1.0, one of our all-purpose, rock-solid generators.
+ * It has excellent (sub-ns) speed, a state (256 bits) that is large
+ * enough for any parallel application, and it passes all tests we are
+ * aware of.
+ *
+ * For generating just floating-point numbers, xoshiro256+ is even faster.
+ */
+class xoshiro256pp final : public detail::xoshiro_base<xoshiro256pp, 4>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro256pp, 4>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint64_t result = boost::core::rotl(state_[0] + state_[3], 23) + state_[0];
+        const std::uint64_t t = state_[1] << 17;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 45);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro256+ 1.0, our best and fastest generator for floating-point
+ * numbers. We suggest to use its upper bits for floating-point
+ * generation, as it is slightly faster than xoshiro256++/xoshiro256**. It
+ * passes all tests we are aware of except for the lowest three bits,
+ * which might fail linearity tests (and just those), so if low linear
+ * complexity is not considered an issue (as it is usually the case) it
+ * can be used to generate 64-bit outputs, too.
+ */
+
+class xoshiro256d final : public detail::xoshiro_base<xoshiro256d, 4, double>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro256d, 4, double>;
+
+public:
+
+    using Base::Base;
+
+    inline std::uint64_t next_int() noexcept
+    {
+        const std::uint64_t result = state_[0] + state_[3];
+        const std::uint64_t t = state_[1] << 17;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 45);
+
+        return result;
+    }
+
+    inline result_type next() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((next_int() >> 11)) * 0x1.0p-53;
+        #else
+        return static_cast<double>((next_int() >> 11)) * 1.11022302462515654e-16;
+        #endif
+    }
+
+    static constexpr result_type (min)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 0x1.0p-53;
+        #else
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 1.11022302462515654e-16;
+        #endif
+    }
+
+    static constexpr result_type (max)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)()) * 0x1.0p-53;
+        #else
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)()) * 1.11022302462515654e-16;
+        #endif
+    }
+};
+
+/**
+ * This is xoshiro256** 1.0, one of our all-purpose, rock-solid
+ * generators. It has excellent (sub-ns) speed, a state (256 bits) that is
+ * large enough for any parallel application, and it passes all tests we
+ * are aware of.
+ *
+ * For generating just floating-point numbers, xoshiro256+ is even faster.
+ */
+
+class xoshiro256mm final : public detail::xoshiro_base<xoshiro256mm, 4>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro256mm, 4>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint64_t result = boost::core::rotl(state_[1] * 5, 7) * 9U;
+        const std::uint64_t t = state_[1] << 17;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 45);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro512++ 1.0, one of our all-purpose, rock-solid
+ * generators. It has excellent (about 1ns) speed, a state (512 bits) that
+ * is large enough for any parallel application, and it passes all tests
+ * we are aware of.
+ *
+ * For generating just floating-point numbers, xoshiro512+ is even faster.
+ *
+ * The state must be seeded so that it is not everywhere zero. If you have
+ * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+ * output to fill s.
+ */
+
+class xoshiro512pp final : public detail::xoshiro_base<xoshiro512pp, 8>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro512pp, 8>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint64_t result = boost::core::rotl(state_[0] + state_[2], 17) + state_[2];
+
+        const std::uint64_t t = state_[1] << 11;
+
+        state_[2] ^= state_[0];
+        state_[5] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[7] ^= state_[3];
+        state_[3] ^= state_[4];
+        state_[4] ^= state_[5];
+        state_[0] ^= state_[6];
+        state_[6] ^= state_[7];
+
+        state_[6] ^= t;
+
+        state_[7] = boost::core::rotl(state_[7], 21);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro512** 1.0, one of our all-purpose, rock-solid generators
+ * with increased state size. It has excellent (about 1ns) speed, a state
+ * (512 bits) that is large enough for any parallel application, and it
+ * passes all tests we are aware of.
+ *
+ * For generating just floating-point numbers, xoshiro512+ is even faster.
+ *
+ * The state must be seeded so that it is not everywhere zero. If you have
+ * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+ *  output to fill s.
+ */
+
+class xoshiro512mm final : public detail::xoshiro_base<xoshiro512mm, 8>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro512mm, 8>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint64_t result = boost::core::rotl(state_[1] * 5, 7) * 9;
+
+        const std::uint64_t t = state_[1] << 11;
+
+        state_[2] ^= state_[0];
+        state_[5] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[7] ^= state_[3];
+        state_[3] ^= state_[4];
+        state_[4] ^= state_[5];
+        state_[0] ^= state_[6];
+        state_[6] ^= state_[7];
+
+        state_[6] ^= t;
+
+        state_[7] = boost::core::rotl(state_[7], 21);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro512+ 1.0, our generator for floating-point numbers with
+ * increased state size. We suggest to use its upper bits for
+ * floating-point generation, as it is slightly faster than xoshiro512**.
+ * It passes all tests we are aware of except for the lowest three bits,
+ * which might fail linearity tests (and just those), so if low linear
+ * complexity is not considered an issue (as it is usually the case) it
+ * can be used to generate 64-bit outputs, too.
+ *
+ * We suggest to use a sign test to extract a random Boolean value, and
+ * right shifts to extract subsets of bits.
+ *
+ * The state must be seeded so that it is not everywhere zero. If you have
+ * a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+ *  output to fill s.
+ */
+
+class xoshiro512d final : public detail::xoshiro_base<xoshiro512d, 8, double>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro512d, 8, double>;
+
+public:
+
+    using Base::Base;
+
+    inline std::uint64_t next_int() noexcept
+    {
+        const std::uint64_t result = state_[0] + state_[2];
+
+        const std::uint64_t t = state_[1] << 11;
+
+        state_[2] ^= state_[0];
+        state_[5] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[7] ^= state_[3];
+        state_[3] ^= state_[4];
+        state_[4] ^= state_[5];
+        state_[0] ^= state_[6];
+        state_[6] ^= state_[7];
+
+        state_[6] ^= t;
+
+        state_[7] = boost::core::rotl(state_[7], 21);
+
+        return result;
+    }
+
+    inline result_type next() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((next_int() >> 11)) * 0x1.0p-53;
+        #else
+        return static_cast<double>((next_int() >> 11)) * 1.11022302462515654e-16;
+        #endif
+    }
+
+    static constexpr result_type (min)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 0x1.0p-53;
+        #else
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::min)() >> 11) * 1.11022302462515654e-16;
+        #endif
+    }
+
+    static constexpr result_type (max)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)() >> 11) * 0x1.0p-53;
+        #else
+        return static_cast<double>((std::numeric_limits<std::uint64_t>::max)() >> 11) * 1.11022302462515654e-16;
+        #endif
+    }
+};
+
+/**
+ * This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid
+ * generators. It has excellent speed, a state size (128 bits) that is
+ * large enough for mild parallelism, and it passes all tests we are aware
+ * of.
+ *
+ * For generating just single-precision (i.e., 32-bit) floating-point
+ * numbers, xoshiro128+ is even faster.
+ *
+ * The state must be seeded so that it is not everywhere zero.
+ */
+class xoshiro128pp final : public detail::xoshiro_base<xoshiro128pp, 4, std::uint32_t, std::uint32_t>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro128pp, 4, std::uint32_t, std::uint32_t>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint32_t result = boost::core::rotl(state_[0] + state_[3], 7) + state_[0];
+
+        const std::uint32_t t = state_[1] << 9;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 11);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro128** 1.1, one of our 32-bit all-purpose, rock-solid
+ * generators. It has excellent speed, a state size (128 bits) that is
+ * large enough for mild parallelism, and it passes all tests we are aware
+ * of.
+ *
+ * Note that version 1.0 had mistakenly state_[0] instead of state_[1] as state
+ * word passed to the scrambler.
+ *
+ * For generating just single-precision (i.e., 32-bit) floating-point
+ * numbers, xoshiro128+ is even faster.
+ *
+ * The state must be seeded so that it is not everywhere zero.
+ */
+class xoshiro128mm final : public detail::xoshiro_base<xoshiro128mm, 4, std::uint32_t, std::uint32_t>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro128mm, 4, std::uint32_t, std::uint32_t>;
+
+public:
+
+    using Base::Base;
+
+    inline result_type next() noexcept
+    {
+        const std::uint32_t result = boost::core::rotl(state_[1] * 5, 7) * 9;
+
+        const std::uint32_t t = state_[1] << 9;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 11);
+
+        return result;
+    }
+};
+
+/**
+ * This is xoshiro128+ 1.0, our best and fastest 32-bit generator for 32-bit
+ * floating-point numbers. We suggest to use its upper bits for
+ * floating-point generation, as it is slightly faster than xoshiro128**.
+ * It passes all tests we are aware of except for
+ * linearity tests, as the lowest four bits have low linear complexity, so
+ * if low linear complexity is not considered an issue (as it is usually
+ * the case) it can be used to generate 32-bit outputs, too.
+ *
+ * We suggest to use a sign test to extract a random Boolean value, and
+ * right shifts to extract subsets of bits.
+ *
+ * The state must be seeded so that it is not everywhere zero.
+ */
+
+class xoshiro128f final : public detail::xoshiro_base<xoshiro128f, 4, float, std::uint32_t>
+{
+private:
+
+    using Base = detail::xoshiro_base<xoshiro128f, 4, float, std::uint32_t>;
+
+public:
+
+    using Base::Base;
+
+    inline std::uint32_t next_int() noexcept
+    {
+        const std::uint32_t result = state_[0] + state_[3];
+
+        const std::uint32_t t = state_[1] << 9;
+
+        state_[2] ^= state_[0];
+        state_[3] ^= state_[1];
+        state_[1] ^= state_[2];
+        state_[0] ^= state_[3];
+
+        state_[2] ^= t;
+
+        state_[3] = boost::core::rotl(state_[3], 11);
+
+        return result;
+    }
+
+    inline result_type next() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<float>((next_int() >> 8)) * 0x1.0p-24f;
+        #else
+        return static_cast<float>((next_int() >> 8)) * 5.9604645e-08f;
+        #endif
+    }
+
+    static constexpr result_type (min)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<float>((std::numeric_limits<std::uint32_t>::min)() >> 8) * 0x1.0p-24f;
+        #else
+        return static_cast<float>((std::numeric_limits<std::uint64_t>::min)() >> 8) * 5.9604645e-08f;
+        #endif
+    }
+
+    static constexpr result_type (max)() noexcept
+    {
+        #ifdef BOOST_RANDOM_HAS_HEX_FLOAT
+        return static_cast<float>((std::numeric_limits<std::uint32_t>::max)() >> 8) * 0x1.0p-24f;
+        #else
+        return static_cast<float>((std::numeric_limits<std::uint64_t>::max)() >> 8) * 5.9604645e-08f;
+        #endif
+    }
+};
+
+} // namespace random
+} // namespace boost
+
+#endif //BOOST_RANDOM_XOSHIRO_HPP

data/src/cxx_supportlib/vendor-modified/boost/random.hpp

@@ -49,6 +49,7 @@
 #include <boost/random/taus88.hpp>
 #include <boost/random/xor_combine.hpp>
 #include <boost/random/splitmix64.hpp>
+#include <boost/random/xoshiro.hpp>
 
 // misc
 #include <boost/random/generate_canonical.hpp>
@@ -87,6 +88,8 @@
 #include <boost/random/uniform_real_distribution.hpp>
 #include <boost/random/uniform_smallint.hpp>
 #include <boost/random/weibull_distribution.hpp>
+#include <boost/random/inverse_gaussian_distribution.hpp>
+#include <boost/random/generalized_inverse_gaussian_distribution.hpp>
 
 #include <boost/random/generate_canonical.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/range/concepts.hpp

@@ -23,7 +23,9 @@
 #include <boost/range/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/detail/misc_concept.hpp>
+#include <boost/mpl/assert.hpp>
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_integral.hpp>
 
 #include <iterator>
 

data/src/cxx_supportlib/vendor-modified/boost/range/detail/has_member_size.hpp

@@ -13,6 +13,7 @@
 
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/mpl/if.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/cstdint.hpp>

data/src/cxx_supportlib/vendor-modified/boost/range/detail/msvc_has_iterator_workaround.hpp

@@ -20,6 +20,8 @@
 #endif
 
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1600)
+#include <boost/mpl/bool.hpp>
+
 namespace boost
 {
 namespace cb_details

data/src/cxx_supportlib/vendor-modified/boost/range/has_range_iterator.hpp

@@ -18,7 +18,7 @@
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/range/iterator.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 
 namespace boost
 {

data/src/cxx_supportlib/vendor-modified/boost/range/iterator.hpp

@@ -22,6 +22,7 @@
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
 
 namespace boost
 {

data/src/cxx_supportlib/vendor-modified/boost/range/iterator_range_core.hpp

@@ -26,8 +26,11 @@
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/not.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/identity.hpp>
 #include <boost/type_traits/is_abstract.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
@@ -41,7 +44,7 @@
 #include <boost/range/has_range_iterator.hpp>
 #include <boost/range/algorithm/equal.hpp>
 #include <boost/range/detail/safe_bool.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/next_prior.hpp>
 #include <iterator>
 #include <algorithm>

data/src/cxx_supportlib/vendor-modified/boost/range/size_type.hpp

@@ -20,7 +20,7 @@
 #include <boost/range/concepts.hpp>
 #include <boost/range/has_range_iterator.hpp>
 
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <cstddef>

data/src/cxx_supportlib/vendor-modified/boost/regex/concepts.hpp

@@ -24,7 +24,7 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/static_assert.hpp>
-#ifndef BOOST_TEST_TR1_REGEX
+#if !defined(BOOST_TEST_TR1_REGEX) && !defined(BOOST_REGEX_TEST_MODULE)
 #include <boost/regex.hpp>
 #endif
 #include <bitset>
@@ -37,6 +37,16 @@
 #define RW_NS std
 #endif
 
+
+  //
+  // alter this to std::tr1, to test a std implementation:
+  //
+#ifndef BOOST_TEST_TR1_REGEX
+namespace global_regex_namespace = ::boost;
+#else
+namespace global_regex_namespace = ::std::tr1;
+#endif
+
 namespace boost{
 
 //
@@ -76,13 +86,10 @@ inline long hash_value(char_architype val)
 //
 } // namespace boost
 namespace std{
-   template<> struct char_traits<boost::char_architype>
-   {
-      // The intent is that this template is not instantiated,
-      // but this typedef gives us a chance of compilation in
-      // case it is:
-      typedef boost::char_architype char_type;
-   };
+   //
+   // We should never use this, if we do it should be an error:
+   //
+   template<> struct char_traits<boost::char_architype>;
 }
 //
 // Allocator architype:
@@ -127,6 +134,9 @@ bool operator == (const allocator_architype<T>&, const allocator_architype<T>&)
 template <class T>
 bool operator != (const allocator_architype<T>&, const allocator_architype<T>&) { return false; }
 
+template <class T>
+void consume_type() {}
+
 namespace boost{
 //
 // regex_traits_architype:
@@ -178,15 +188,6 @@ private:
    regex_traits_architype& operator=(const regex_traits_architype&){ return *this; }
 };
 
-//
-// alter this to std::tr1, to test a std implementation:
-//
-#ifndef BOOST_TEST_TR1_REGEX
-namespace global_regex_namespace = ::boost;
-#else
-namespace global_regex_namespace = ::std::tr1;
-#endif
-
 template <class Bitmask>
 struct BitmaskConcept
 {
@@ -273,7 +274,7 @@ template <class Regex>
 struct regex_traits_computer;
 
 template <class charT, class traits>
-struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
+struct regex_traits_computer< ::boost::basic_regex<charT, traits> >
 {
    typedef traits type;
 };
@@ -371,6 +372,8 @@ struct BaseRegexConcept
       e1 = except.code();
 
       typedef typename Regex::value_type regex_value_type;
+      regex_value_type val{};
+      ignore_unused_variable_warning(val);
       function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();
       function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();
    }
@@ -407,6 +410,10 @@ struct BaseRegexConcept
       Regex e5(in1, in2, m_flags);
       ignore_unused_variable_warning(e5);
 
+      // equals:
+      e1 == e2;
+      e1 != e2;
+
       // assign etc:
       Regex e;
       e = m_pointer;
@@ -446,15 +453,25 @@ struct BaseRegexConcept
       // match_results tests - some typedefs are not used, however these
       // guarante that they exist (some compilers may warn on non-usage)
       typedef typename match_results_type::value_type mr_value_type;
+      consume_type<mr_value_type>();
       typedef typename match_results_type::const_reference mr_const_reference;
+      consume_type<mr_const_reference>();
       typedef typename match_results_type::reference mr_reference;
+      consume_type<mr_reference>();
       typedef typename match_results_type::const_iterator mr_const_iterator;
+      consume_type<mr_const_iterator>();
       typedef typename match_results_type::iterator mr_iterator;
+      consume_type<mr_iterator>();
       typedef typename match_results_type::difference_type mr_difference_type;
+      consume_type<mr_difference_type>();
       typedef typename match_results_type::size_type mr_size_type;
+      consume_type<mr_size_type>();
       typedef typename match_results_type::allocator_type mr_allocator_type;
+      consume_type<mr_allocator_type>();
       typedef typename match_results_type::char_type mr_char_type;
+      consume_type<mr_char_type>();
       typedef typename match_results_type::string_type mr_string_type;
+      consume_type<mr_string_type>();
 
       match_results_type m1;
       mr_allocator_type at;