1 files changed, 4 insertions, 13 deletions
diff --git a/3rdParty/Boost/src/boost/regex/icu.hpp b/3rdParty/Boost/src/boost/regex/icu.hpp
index 772806e..37fec2a 100644
--- a/3rdParty/Boost/src/boost/regex/icu.hpp
+++ b/3rdParty/Boost/src/boost/regex/icu.hpp
@@ -391,87 +391,87 @@ inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boos
 namespace re_detail{
 template<class MR1, class MR2>
 void copy_results(MR1& out, MR2 const& in)
 {
    // copy results from an adapted MR2 match_results:
    out.set_size(in.size(), in.prefix().first.base(), in.suffix().second.base());
    out.set_base(in.base().base());
    for(int i = 0; i < (int)in.size(); ++i)
    {
       if(in[i].matched)
       {
          out.set_first(in[i].first.base(), i);
          out.set_second(in[i].second.base(), i);
       }
    }
 }
 
 template <class BidiIterator, class Allocator>
 inline bool do_regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  boost::mpl::int_<4> const*)
 {
    return ::boost::regex_match(first, last, m, e, flags);
 }
 template <class BidiIterator, class Allocator>
 bool do_regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  boost::mpl::int_<2> const*)
 {
    typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
    typedef match_results<conv_type>                   match_type;
-   typedef typename match_type::allocator_type        alloc_type;
+   //typedef typename match_type::allocator_type        alloc_type;
    match_type what;
    bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
    // copy results across to m:
    if(result) copy_results(m, what);
    return result;
 }
 template <class BidiIterator, class Allocator>
 bool do_regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  boost::mpl::int_<1> const*)
 {
    typedef u8_to_u32_iterator<BidiIterator, UChar32>  conv_type;
    typedef match_results<conv_type>                   match_type;
-   typedef typename match_type::allocator_type        alloc_type;
+   //typedef typename match_type::allocator_type        alloc_type;
    match_type what;
    bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);
    // copy results across to m:
    if(result) copy_results(m, what);
    return result;
 }
 } // namespace re_detail
 
 template <class BidiIterator, class Allocator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return re_detail::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_match(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return re_detail::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const char* p, 
                  match_results<const char*>& m, 
                  const u32regex& e, 
@@ -566,88 +566,88 @@ inline bool u32regex_match(const std::wstring& s,
    return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
 inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
    match_results<const UChar*> m;
    return re_detail::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 
 //
 // regex_search overloads that widen the character type as appropriate:
 //
 namespace re_detail{
 template <class BidiIterator, class Allocator>
 inline bool do_regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  BidiIterator base,
                  boost::mpl::int_<4> const*)
 {
    return ::boost::regex_search(first, last, m, e, flags, base);
 }
 template <class BidiIterator, class Allocator>
 bool do_regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  BidiIterator base,
                  boost::mpl::int_<2> const*)
 {
    typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;
    typedef match_results<conv_type>                   match_type;
-   typedef typename match_type::allocator_type        alloc_type;
+   //typedef typename match_type::allocator_type        alloc_type;
    match_type what;
    bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
    // copy results across to m:
    if(result) copy_results(m, what);
    return result;
 }
 template <class BidiIterator, class Allocator>
 bool do_regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  BidiIterator base,
                  boost::mpl::int_<1> const*)
 {
    typedef u8_to_u32_iterator<BidiIterator, UChar32>  conv_type;
    typedef match_results<conv_type>                   match_type;
-   typedef typename match_type::allocator_type        alloc_type;
+   //typedef typename match_type::allocator_type        alloc_type;
    match_type what;
    bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));
    // copy results across to m:
    if(result) copy_results(m, what);
    return result;
 }
 }
 
 template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return re_detail::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
                  match_flag_type flags,
                  BidiIterator base)
 {
    return re_detail::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
 }
 inline bool u32regex_search(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
 }
 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
@@ -855,117 +855,108 @@ OutputIterator do_regex_replace(OutputIterator out,
          if(flags & regex_constants::format_first_only)
             break;
          ++i;
       }
       if(!(flags & regex_constants::format_no_copy))
          out = re_detail::copy(last_m, in.second, out);
    }
    return out;
 }
 template <class BaseIterator>
 inline const BaseIterator& extract_output_base(const BaseIterator& b)
 {
    return b;
 }
 template <class BaseIterator>
 inline BaseIterator extract_output_base(const utf8_output_iterator<BaseIterator>& b)
 {
    return b.base();
 }
 template <class BaseIterator>
 inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator>& b)
 {
    return b.base();
 }
 }  // re_detail
 
 template <class OutputIterator, class BidirectionalIterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          BidirectionalIterator first,
                          BidirectionalIterator last,
                          const u32regex& e, 
                          const charT* fmt, 
                          match_flag_type flags = match_default)
 {
    return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-   <OutputIterator>
-#endif
     (
       re_detail::do_regex_replace(
          re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
          re_detail::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
          flags)
       );
 }
 
 template <class OutputIterator, class Iterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
                          const u32regex& e, 
                          const std::basic_string<charT>& fmt,
                          match_flag_type flags = match_default)
 {
    return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-   <OutputIterator>
-#endif
     (
       re_detail::do_regex_replace(
          re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
          re_detail::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
          flags)
       );
 }
 
 template <class OutputIterator, class Iterator>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
                          const u32regex& e, 
                          const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
                          match_flag_type flags = match_default)
 {
    return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-   <OutputIterator>
-#endif
    (
       re_detail::do_regex_replace(
          re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
          e,
          re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
          flags)
       );
 }
 
 template <class charT>
 std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          const u32regex& e, 
                          const charT* fmt,
                          match_flag_type flags = match_default)
 {
    std::basic_string<charT> result;
    re_detail::string_out_iterator<std::basic_string<charT> > i(result);
    u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);
    return result;
 }
 
 template <class charT>
 std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          const u32regex& e, 
                          const std::basic_string<charT>& fmt,
                          match_flag_type flags = match_default)
 {
    std::basic_string<charT> result;
    re_detail::string_out_iterator<std::basic_string<charT> > i(result);
    u32regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
    return result;
 }
 
 namespace re_detail{