passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/sub_match.hpp

@@ -35,11 +35,11 @@ namespace boost{
 template <class BidiIterator>
 struct sub_match : public std::pair<BidiIterator, BidiIterator>
 {
-   typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type       value_type;
-#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::value_type       value_type;
+#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
    typedef          std::ptrdiff_t                                                   difference_type;
 #else
-   typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type  difference_type;
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::difference_type  difference_type;
 #endif
    typedef          BidiIterator                                                     iterator_type;
    typedef          BidiIterator                                                     iterator;
@@ -50,7 +50,6 @@ struct sub_match : public std::pair<BidiIterator, BidiIterator>
    sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
    sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
 #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
-               && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)\
                && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\
                && !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
    template <class T, class A>
@@ -66,7 +65,7 @@ struct sub_match : public std::pair<BidiIterator, BidiIterator>
 #endif
    difference_type BOOST_REGEX_CALL length()const
    {
-      difference_type n = matched ? ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
+      difference_type n = matched ? ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
       return n;
    }
    std::basic_string<value_type> str()const
@@ -74,7 +73,7 @@ struct sub_match : public std::pair<BidiIterator, BidiIterator>
       std::basic_string<value_type> result;
       if(matched)
       {
-         std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);
+         std::size_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second);
          result.reserve(len);
          BidiIterator i = this->first;
          while(i != this->second)
@@ -163,6 +162,11 @@ public:
 #endif
       return *this;
    }
+   //
+   // Make this type a range, for both Boost.Range, and C++11:
+   //
+   BidiIterator begin()const { return this->first; }
+   BidiIterator end()const { return this->second; }
 
 
 #ifdef BOOST_OLD_REGEX_H
@@ -191,235 +195,235 @@ typedef sub_match<std::wstring::const_iterator> wssub_match;
 
 // comparison to std::basic_string<> part 1:
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator == (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator == (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) == 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator != (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator != (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) != 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator < (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator < (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                  const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) < 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator <= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator <= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) <= 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator >= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator >= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) >= 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline bool operator > (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline bool operator > (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                  const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) > 0; }
 // comparison to std::basic_string<> part 2:
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) == 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) != 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) < 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) > 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) <= 0; }
 template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
-                  const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+                  const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) >= 0; }
 // comparison to const charT* part 1:
 template <class RandomAccessIterator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) == 0; }
 template <class RandomAccessIterator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) != 0; }
 template <class RandomAccessIterator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) > 0; }
 template <class RandomAccessIterator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) < 0; }
 template <class RandomAccessIterator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) >= 0; }
 template <class RandomAccessIterator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) <= 0; }
 // comparison to const charT* part 2:
 template <class RandomAccessIterator>
-inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator == (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) == 0; }
 template <class RandomAccessIterator>
-inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator != (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) != 0; }
 template <class RandomAccessIterator>
-inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator < (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) > 0; }
 template <class RandomAccessIterator>
-inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator > (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) < 0; }
 template <class RandomAccessIterator>
-inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) >= 0; }
 template <class RandomAccessIterator>
-inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) <= 0; }
 
 // comparison to const charT& part 1:
 template <class RandomAccessIterator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) == 0; }
 template <class RandomAccessIterator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) != 0; }
 template <class RandomAccessIterator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) > 0; }
 template <class RandomAccessIterator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) < 0; }
 template <class RandomAccessIterator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) >= 0; }
 template <class RandomAccessIterator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
-                  typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+                  typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) <= 0; }
 // comparison to const charT* part 2:
 template <class RandomAccessIterator>
-inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator == (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) == 0; }
 template <class RandomAccessIterator>
-inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator != (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) != 0; }
 template <class RandomAccessIterator>
-inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator < (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) > 0; }
 template <class RandomAccessIterator>
-inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator > (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) < 0; }
 template <class RandomAccessIterator>
-inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) >= 0; }
 template <class RandomAccessIterator>
-inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) <= 0; }
 
 // addition operators:
 template <class RandomAccessIterator, class traits, class Allocator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
-operator + (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
+operator + (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
    result.reserve(s.size() + m.length() + 1);
    return result.append(s).append(m.first, m.second);
 }
 template <class RandomAccessIterator, class traits, class Allocator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
 operator + (const sub_match<RandomAccessIterator>& m,
-            const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
+            const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
    result.reserve(s.size() + m.length() + 1);
    return result.append(m.first, m.second).append(s);
 }
 #if !(defined(__GNUC__) && defined(BOOST_NO_STD_LOCALE))
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
-operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
+operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
-   result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
+   result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
    return result.append(s).append(m.first, m.second);
 }
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m,
-            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
+            typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
-   result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
+   result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
    return result.append(m.first, m.second).append(s);
 }
 #else
 // worwaround versions:
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
-operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
+operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 {
    return s + m.str();
 }
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m,
-            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
+            typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
 {
    return m.str() + s;
 }
 #endif
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
-operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
+operator + (typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
    result.reserve(m.length() + 2);
    return result.append(1, s).append(m.first, m.second);
 }
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m,
-            typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
+            typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
    result.reserve(m.length() + 2);
    return result.append(m.first, m.second).append(1, s);
 }
 template <class RandomAccessIterator>
-inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 
+inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m1,
             const sub_match<RandomAccessIterator>& m2)
 {
-   std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
+   std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
    result.reserve(m1.length() + m2.length() + 1);
    return result.append(m1.first, m1.second).append(m2.first, m2.second);
 }
@@ -441,7 +445,7 @@ std::ostream& operator << (std::ostream& os,
 #endif
 
 #ifdef BOOST_OLD_REGEX_H
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 template <class BidiIterator, class charT>
 int do_toi(BidiIterator i, BidiIterator j, char c, int radix)
 {
@@ -480,7 +484,7 @@ sub_match<BidiIterator>::operator int()const
       neg = -1;
       ++i;
    }
-   neg *= re_detail::do_toi(i, j, *i);
+   neg *= BOOST_REGEX_DETAIL_NS::do_toi(i, j, *i);
    if(i != j)raise_regex_exception("Bad sub-expression");
    return neg;
 }
@@ -491,7 +495,7 @@ sub_match<BidiIterator>::operator unsigned int()const
    BidiIterator j = second;
    if(i == j)
       raise_regex_exception("Bad sub-expression");
-   return re_detail::do_toi(i, j, *first);
+   return BOOST_REGEX_DETAIL_NS::do_toi(i, j, *first);
 }
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/u32regex_iterator.hpp

@@ -76,7 +76,7 @@ class u32regex_iterator
    : public std::iterator<
          std::forward_iterator_tag, 
          match_results<BidirectionalIterator>,
-         typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
          const match_results<BidirectionalIterator>*,
          const match_results<BidirectionalIterator>& >         
 #endif
@@ -87,7 +87,7 @@ private:
 public:
    typedef          u32regex                                                regex_type;
    typedef          match_results<BidirectionalIterator>                    value_type;
-   typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type 
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type 
                                                                             difference_type;
    typedef          const value_type*                                       pointer;
    typedef          const value_type&                                       reference; 

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/u32regex_token_iterator.hpp

@@ -20,7 +20,6 @@
 #define BOOST_REGEX_V4_U32REGEX_TOKEN_ITERATOR_HPP
 
 #if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
-      || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
 //
 // Borland C++ Builder 6, and Visual C++ 6,
@@ -37,7 +36,7 @@ namespace boost{
 #ifdef BOOST_HAS_ABI_HEADERS
 #  include BOOST_ABI_PREFIX
 #endif
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
+#ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable:4700)
 #endif
@@ -62,10 +61,7 @@ public:
       : end(last), re(*p), flags(f){ subs.push_back(sub); }
    u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)
       : end(last), re(*p), flags(f), subs(v){}
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      // can't reliably get this to work....
-#elif (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
-      || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
       || BOOST_WORKAROUND(__HP_aCC, < 60700)
    template <class T>
@@ -163,7 +159,7 @@ class u32regex_token_iterator
    : public std::iterator<
          std::forward_iterator_tag, 
          sub_match<BidirectionalIterator>,
-         typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
          const sub_match<BidirectionalIterator>*,
          const sub_match<BidirectionalIterator>& >         
 #endif
@@ -174,7 +170,7 @@ private:
 public:
    typedef          u32regex                                                regex_type;
    typedef          sub_match<BidirectionalIterator>                        value_type;
-   typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type 
+   typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type 
                                                                             difference_type;
    typedef          const value_type*                                       pointer;
    typedef          const value_type&                                       reference; 
@@ -195,10 +191,7 @@ public:
       if(!pdata->init(a))
          pdata.reset();
    }
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      // can't reliably get this to work....
-#elif (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
-      || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
       || BOOST_WORKAROUND(__HP_aCC, < 60700)
    template <class T>
@@ -299,7 +292,6 @@ inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const
    return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
 }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 // construction from a reference to an array:
 template <std::size_t N>
 inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
@@ -331,7 +323,6 @@ inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const
 {
    return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
 }
-#endif // BOOST_MSVC < 1300
 
 // construction from a vector of sub_match state_id's:
 inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
@@ -361,7 +352,7 @@ inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const
    return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
 }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
+#ifdef BOOST_MSVC
 #  pragma warning(pop)
 #endif
 #ifdef BOOST_HAS_ABI_HEADERS