passenger 5.0.24 → 5.0.25

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

@@ -31,7 +31,7 @@
 #endif
 
 namespace boost{
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -68,6 +68,8 @@ public:
    bool parse_inner_set(basic_char_set<charT, traits>& char_set);
    bool parse_QE();
    bool parse_perl_extension();
+   bool parse_perl_verb();
+   bool match_verb(const char*);
    bool add_emacs_code(bool negate);
    bool unwind_alts(std::ptrdiff_t last_paren_start);
    digraph<charT> get_next_set_literal(basic_char_set<charT, traits>& char_set);
@@ -165,7 +167,7 @@ void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2,
    // have had an unexpected ')' :
    if(!result)
    {
-      fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
+      fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
       return;
    }
    // if an error has been set then give up now:
@@ -346,8 +348,13 @@ bool basic_regex_parser<charT, traits>::parse_extended()
       ++m_position;
       return parse_repeat_range(false);
    case regex_constants::syntax_close_brace:
-      fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");
-      return false;
+      if((this->flags() & regbase::no_perl_ex) == regbase::no_perl_ex)
+      {
+         fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");
+         return false;
+      }
+      result = parse_literal();
+      break;
    case regex_constants::syntax_or:
       return parse_alt();
    case regex_constants::syntax_open_set:
@@ -416,6 +423,8 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
    {
       if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)
          return parse_perl_extension();
+      if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_star)
+         return parse_perl_verb();
    }
    //
    // update our mark count, and append the required state:
@@ -484,7 +493,7 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
    //
    if(m_position == m_end)
    {
-      this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
+      this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
       return false;
    }
    BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@@ -919,9 +928,9 @@ bool basic_regex_parser<charT, traits>::parse_match_any()
    static_cast<re_dot*>(
       this->append_state(syntax_element_wild, sizeof(re_dot))
       )->mask = static_cast<unsigned char>(this->flags() & regbase::no_mod_s 
-      ? re_detail::force_not_newline 
+      ? BOOST_REGEX_DETAIL_NS::force_not_newline 
          : this->flags() & regbase::mod_s ?
-            re_detail::force_newline : re_detail::dont_care);
+            BOOST_REGEX_DETAIL_NS::force_newline : BOOST_REGEX_DETAIL_NS::dont_care);
    return true;
 }
 
@@ -958,7 +967,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
    }
    if(0 == this->m_last_state)
    {
-      fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position), "Nothing to repeat.");
+      fail(regex_constants::error_badrepeat, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Nothing to repeat.");
       return false;
    }
    if(this->m_last_state->type == syntax_element_endmark)
@@ -971,7 +980,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
       // the last state was a literal with more than one character, split it in two:
       re_literal* lit = static_cast<re_literal*>(this->m_last_state);
       charT c = (static_cast<charT*>(static_cast<void*>(lit+1)))[lit->length - 1];
-      --(lit->length);
+      lit->length -= 1;
       // now append new state:
       lit = static_cast<re_literal*>(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));
       lit->length = 1;
@@ -1215,7 +1224,7 @@ bool basic_regex_parser<charT, traits>::parse_alt()
         )
       )
    {
-      fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression can start with the alternation operator |.");
+      fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression cannot start with the alternation operator |.");
       return false;
    }
    //
@@ -1230,7 +1239,7 @@ bool basic_regex_parser<charT, traits>::parse_alt()
    //
    // we need to append a trailing jump: 
    //
-   re_syntax_base* pj = this->append_state(re_detail::syntax_element_jump, sizeof(re_jump));
+   re_syntax_base* pj = this->append_state(BOOST_REGEX_DETAIL_NS::syntax_element_jump, sizeof(re_jump));
    std::ptrdiff_t jump_offset = this->getoffset(pj);
    //
    // now insert the alternative:
@@ -1779,7 +1788,7 @@ charT basic_regex_parser<charT, traits>::unescape_character()
       {
       // an octal escape sequence, the first character must be a zero
       // followed by up to 3 octal digits:
-      std::ptrdiff_t len = (std::min)(::boost::re_detail::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
+      std::ptrdiff_t len = (std::min)(::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));
       const charT* bp = m_position;
       int val = this->m_traits.toi(bp, bp + 1, 8);
       if(val != 0)
@@ -2516,7 +2525,7 @@ option_group_jump:
       // Rewind to start of (? sequence:
       --m_position;
       while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
-      this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
+      this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
       return false;
    }
    BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@@ -2647,6 +2656,194 @@ option_group_jump:
    return true;
 }
 
+template <class charT, class traits>
+bool basic_regex_parser<charT, traits>::match_verb(const char* verb)
+{
+   while(*verb)
+   {
+      if(static_cast<charT>(*verb) != *m_position)
+      {
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(++m_position == m_end)
+      {
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      ++verb;
+   }
+   return true;
+}
+
+template <class charT, class traits>
+bool basic_regex_parser<charT, traits>::parse_perl_verb()
+{
+   if(++m_position == m_end)
+   {
+      // Rewind to start of (* sequence:
+      --m_position;
+      while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+      fail(regex_constants::error_perl_extension, m_position - m_base);
+      return false;
+   }
+   switch(*m_position)
+   {
+   case 'F':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if((this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark) || match_verb("AIL"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_fail);
+         return true;
+      }
+      break;
+   case 'A':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("CCEPT"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_accept);
+         return true;
+      }
+      break;
+   case 'C':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("OMMIT"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_commit;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'P':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("RUNE"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_prune;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'S':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("KIP"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         static_cast<re_commit*>(this->append_state(syntax_element_commit, sizeof(re_commit)))->action = commit_skip;
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   case 'T':
+      if(++m_position == m_end)
+      {
+         // Rewind to start of (* sequence:
+         --m_position;
+         while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+         fail(regex_constants::error_perl_extension, m_position - m_base);
+         return false;
+      }
+      if(match_verb("HEN"))
+      {
+         if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))
+         {
+            // Rewind to start of (* sequence:
+            --m_position;
+            while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
+            fail(regex_constants::error_perl_extension, m_position - m_base);
+            return false;
+         }
+         ++m_position;
+         this->append_state(syntax_element_then);
+         this->m_pdata->m_disable_match_any = true;
+         return true;
+      }
+      break;
+   }
+   return false;
+}
+
 template <class charT, class traits>
 bool basic_regex_parser<charT, traits>::add_emacs_code(bool negate)
 {
@@ -2857,7 +3054,7 @@ bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_st
 #pragma warning(pop)
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 } // namespace boost
 
 #ifdef BOOST_MSVC

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

@@ -21,6 +21,7 @@
 
 #include <boost/config.hpp>
 #include <boost/integer.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
 
 #ifndef BOOST_NO_STD_LOCALE
 
@@ -68,7 +69,7 @@ namespace boost{
 template <class charT>
 class cpp_regex_traits;
    
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // class parser_buf:
@@ -289,7 +290,7 @@ void cpp_regex_traits_char_layer<charT>::init()
       {
          std::string m("Unable to open message catalog: ");
          std::runtime_error err(m + cat_name);
-         boost::re_detail::raise_runtime_error(err);
+         boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
       }
    }
    //
@@ -414,8 +415,9 @@ template <class charT>
 class cpp_regex_traits_implementation : public cpp_regex_traits_char_layer<charT>
 {
 public:
-   typedef typename cpp_regex_traits<charT>::char_class_type char_class_type;
-   typedef typename std::ctype<charT>::mask                  native_mask_type;
+   typedef typename cpp_regex_traits<charT>::char_class_type      char_class_type;
+   typedef typename std::ctype<charT>::mask                       native_mask_type;
+   typedef typename boost::make_unsigned<native_mask_type>::type  unsigned_native_mask_type;
 #ifndef BOOST_REGEX_BUGGY_CTYPE_FACET
    BOOST_STATIC_CONSTANT(char_class_type, mask_blank = 1u << 24);
    BOOST_STATIC_CONSTANT(char_class_type, mask_word = 1u << 25);
@@ -507,8 +509,18 @@ typename cpp_regex_traits_implementation<charT>::string_type
    // we adhere to gcc's (buggy) preconditions...
    //
    BOOST_ASSERT(*p2 == 0);
-
    string_type result;
+#if defined(_CPPLIB_VER)
+   //
+   // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+   // to std::collate::transform, but only for certain locales :-(
+   // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+   //
+   if(*p1 == 0)
+   {
+      return string_type(1, charT(0));
+   }
+#endif
    //
    // swallowing all exceptions here is a bad idea
    // however at least one std lib will always throw
@@ -582,7 +594,18 @@ typename cpp_regex_traits_implementation<charT>::string_type
    // however at least one std lib will always throw
    // std::bad_alloc for certain arguments...
    //
-   string_type result;
+   string_type result, result2;
+#if defined(_CPPLIB_VER)
+   //
+   // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+   // to std::collate::transform, but only for certain locales :-(
+   // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+   //
+   if(*p1 == 0)
+   {
+      return result;
+   }
+#endif
 #ifndef BOOST_NO_EXCEPTIONS
    try{
 #endif
@@ -601,14 +624,36 @@ typename cpp_regex_traits_implementation<charT>::string_type
       while(result.size() && (charT(0) == *result.rbegin()))
          result.erase(result.size() - 1);
 #endif
-      BOOST_ASSERT(std::find(result.begin(), result.end(), charT(0)) == result.end());
+      //
+      // We may have NULL's used as separators between sections of the collate string,
+      // an example would be Boost.Locale.  We have no way to detect this case via
+      // #defines since this can be used with any compiler/platform combination.
+      // Unfortunately our state machine (which was devised when all implementations
+      // used underlying C language API's) can't cope with that case.  One workaround
+      // is to replace each character with 2, fortunately this code isn't used that
+      // much as this is now slower than before :-(
+      //
+      typedef typename make_unsigned<charT>::type uchar_type;
+      result2.reserve(result.size() * 2 + 2);
+      for(unsigned i = 0; i < result.size(); ++i)
+      {
+         if(static_cast<uchar_type>(result[i]) == (std::numeric_limits<uchar_type>::max)())
+         {
+            result2.append(1, charT((std::numeric_limits<uchar_type>::max)())).append(1, charT('b'));
+         }
+         else
+         {
+            result2.append(1, static_cast<charT>(1 + static_cast<uchar_type>(result[i]))).append(1, charT('b') - 1);
+         }
+      }
+      BOOST_ASSERT(std::find(result2.begin(), result2.end(), charT(0)) == result2.end());
 #ifndef BOOST_NO_EXCEPTIONS
    }
    catch(...)
    {
    }
 #endif
-   return result;
+   return result2;
 }
 
 
@@ -624,7 +669,6 @@ typename cpp_regex_traits_implementation<charT>::string_type
          return pos->second;
    }
 #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
-               && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
                && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
    std::string name(p1, p2);
 #else
@@ -635,7 +679,6 @@ typename cpp_regex_traits_implementation<charT>::string_type
 #endif
    name = lookup_default_collate_name(name);
 #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
-               && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
                && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
    if(name.size())
       return string_type(name.begin(), name.end());
@@ -675,7 +718,7 @@ void cpp_regex_traits_implementation<charT>::init()
       {
          std::string m("Unable to open message catalog: ");
          std::runtime_error err(m + cat_name);
-         boost::re_detail::raise_runtime_error(err);
+         boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
       }
    }
    //
@@ -711,19 +754,19 @@ void cpp_regex_traits_implementation<charT>::init()
 #ifndef BOOST_REGEX_BUGGY_CTYPE_FACET
       static const char_class_type masks[16] = 
       {
-         std::ctype<charT>::alnum,
-         std::ctype<charT>::alpha,
-         std::ctype<charT>::cntrl,
-         std::ctype<charT>::digit,
-         std::ctype<charT>::graph,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::alnum),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::alpha),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::cntrl),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::digit),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::graph),
          cpp_regex_traits_implementation<charT>::mask_horizontal,
-         std::ctype<charT>::lower,
-         std::ctype<charT>::print,
-         std::ctype<charT>::punct,
-         std::ctype<charT>::space,
-         std::ctype<charT>::upper,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::lower),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::print),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::punct),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::space),
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::upper),
          cpp_regex_traits_implementation<charT>::mask_vertical,
-         std::ctype<charT>::xdigit,
+         static_cast<unsigned_native_mask_type>(std::ctype<charT>::xdigit),
          cpp_regex_traits_implementation<charT>::mask_blank,
          cpp_regex_traits_implementation<charT>::mask_word,
          cpp_regex_traits_implementation<charT>::mask_unicode,
@@ -731,22 +774,22 @@ void cpp_regex_traits_implementation<charT>::init()
 #else
       static const char_class_type masks[16] = 
       {
-         ::boost::re_detail::char_class_alnum,
-         ::boost::re_detail::char_class_alpha,
-         ::boost::re_detail::char_class_cntrl,
-         ::boost::re_detail::char_class_digit,
-         ::boost::re_detail::char_class_graph,
-         ::boost::re_detail::char_class_horizontal_space,
-         ::boost::re_detail::char_class_lower,
-         ::boost::re_detail::char_class_print,
-         ::boost::re_detail::char_class_punct,
-         ::boost::re_detail::char_class_space,
-         ::boost::re_detail::char_class_upper,
-         ::boost::re_detail::char_class_vertical_space,
-         ::boost::re_detail::char_class_xdigit,
-         ::boost::re_detail::char_class_blank,
-         ::boost::re_detail::char_class_word,
-         ::boost::re_detail::char_class_unicode,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_word,
+         ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
       };
 #endif
       static const string_type null_string;
@@ -761,7 +804,7 @@ void cpp_regex_traits_implementation<charT>::init()
    //
    // get the collation format used by m_pcollate:
    //
-   m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);
+   m_collate_type = BOOST_REGEX_DETAIL_NS::find_sort_syntax(this, &m_collate_delim);
 }
 
 template <class charT>
@@ -772,53 +815,53 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
    static const char_class_type masks[22] = 
    {
       0,
-      std::ctype<char>::alnum, 
-      std::ctype<char>::alpha,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alpha),
       cpp_regex_traits_implementation<charT>::mask_blank,
-      std::ctype<char>::cntrl,
-      std::ctype<char>::digit,
-      std::ctype<char>::digit,
-      std::ctype<char>::graph,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::cntrl),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::digit),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::digit),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::graph),
       cpp_regex_traits_implementation<charT>::mask_horizontal,
-      std::ctype<char>::lower,
-      std::ctype<char>::lower,
-      std::ctype<char>::print,
-      std::ctype<char>::punct,
-      std::ctype<char>::space,
-      std::ctype<char>::space,
-      std::ctype<char>::upper,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::lower),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::lower),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::print),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::punct),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::space),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::space),
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::upper),
       cpp_regex_traits_implementation<charT>::mask_unicode,
-      std::ctype<char>::upper,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::upper),
       cpp_regex_traits_implementation<charT>::mask_vertical,
-      std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word, 
-      std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word, 
-      std::ctype<char>::xdigit,
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum) | cpp_regex_traits_implementation<charT>::mask_word, 
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::alnum) | cpp_regex_traits_implementation<charT>::mask_word, 
+      static_cast<unsigned_native_mask_type>(std::ctype<char>::xdigit),
    };
 #else
    static const char_class_type masks[22] = 
    {
       0,
-      ::boost::re_detail::char_class_alnum, 
-      ::boost::re_detail::char_class_alpha,
-      ::boost::re_detail::char_class_blank,
-      ::boost::re_detail::char_class_cntrl,
-      ::boost::re_detail::char_class_digit,
-      ::boost::re_detail::char_class_digit,
-      ::boost::re_detail::char_class_graph,
-      ::boost::re_detail::char_class_horizontal_space,
-      ::boost::re_detail::char_class_lower,
-      ::boost::re_detail::char_class_lower,
-      ::boost::re_detail::char_class_print,
-      ::boost::re_detail::char_class_punct,
-      ::boost::re_detail::char_class_space,
-      ::boost::re_detail::char_class_space,
-      ::boost::re_detail::char_class_upper,
-      ::boost::re_detail::char_class_unicode,
-      ::boost::re_detail::char_class_upper,
-      ::boost::re_detail::char_class_vertical_space,
-      ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word, 
-      ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word, 
-      ::boost::re_detail::char_class_xdigit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word, 
+      ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
    };
 #endif
    if(m_custom_class_names.size())
@@ -828,7 +871,7 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
       if(pos != m_custom_class_names.end())
          return pos->second;
    }
-   std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+   std::size_t state_id = 1 + BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
    BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
    return masks[state_id];
 }
@@ -838,32 +881,32 @@ template <class charT>
 bool cpp_regex_traits_implementation<charT>::isctype(const charT c, char_class_type mask) const
 {
    return
-      ((mask & ::boost::re_detail::char_class_space) && (this->m_pctype->is(std::ctype<charT>::space, c)))
-      || ((mask & ::boost::re_detail::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
-      || ((mask & ::boost::re_detail::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
-      || ((mask & ::boost::re_detail::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
-      || ((mask & ::boost::re_detail::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
-      || ((mask & ::boost::re_detail::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
-      || ((mask & ::boost::re_detail::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
-      || ((mask & ::boost::re_detail::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
-      || ((mask & ::boost::re_detail::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
-      || ((mask & ::boost::re_detail::char_class_blank) && (this->m_pctype->is(std::ctype<charT>::space, c)) && !::boost::re_detail::is_separator(c))
-      || ((mask & ::boost::re_detail::char_class_word) && (c == '_'))
-      || ((mask & ::boost::re_detail::char_class_unicode) && ::boost::re_detail::is_extended(c))
-      || ((mask & ::boost::re_detail::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
-      || ((mask & ::boost::re_detail::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
+      ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_space) && (this->m_pctype->is(std::ctype<charT>::space, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank) && (this->m_pctype->is(std::ctype<charT>::space, c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_word) && (c == '_'))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode) && ::boost::BOOST_REGEX_DETAIL_NS::is_extended(c))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
+      || ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
 }
 #endif
 
 
 template <class charT>
-inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(charT))
+inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l)
 {
    cpp_regex_traits_base<charT> key(l);
    return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);
 }
 
-} // re_detail
+} // BOOST_REGEX_DETAIL_NS
 
 template <class charT>
 class cpp_regex_traits
@@ -880,7 +923,7 @@ public:
    struct boost_extensions_tag{};
 
    cpp_regex_traits()
-      : m_pimpl(re_detail::create_cpp_regex_traits<charT>(std::locale()))
+      : m_pimpl(BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(std::locale()))
    { }
    static size_type length(const char_type* p)
    {
@@ -953,20 +996,32 @@ public:
          && (m_pimpl->m_pctype->is(
             static_cast<ctype_mask>(f & mask_base), c)))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_unicode) && re_detail::is_extended(c))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_blank) 
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_blank) 
          && m_pimpl->m_pctype->is(std::ctype<charT>::space, c)
-         && !re_detail::is_separator(c))
+         && !BOOST_REGEX_DETAIL_NS::is_separator(c))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_vertical) 
-         && (::boost::re_detail::is_separator(c) || (c == '\v')))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical) 
+         && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
          return true;
-      else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_horizontal) 
-         && this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, re_detail::cpp_regex_traits_implementation<charT>::mask_vertical))
+      else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_horizontal) 
+         && this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical))
          return true;
+#ifdef __CYGWIN__
+      //
+      // Cygwin has a buggy ctype facet, see https://www.cygwin.com/ml/cygwin/2012-08/msg00178.html:
+      //
+      else if((f & std::ctype<charT>::xdigit) == std::ctype<charT>::xdigit)
+      {
+         if((c >= 'a') && (c <= 'f'))
+            return true;
+         if((c >= 'A') && (c <= 'F'))
+            return true;
+      }
+#endif
       return false;
 #else
       return m_pimpl->isctype(c, f);
@@ -981,7 +1036,7 @@ public:
    locale_type imbue(locale_type l)
    {
       std::locale result(getloc());
-      m_pimpl = re_detail::create_cpp_regex_traits<charT>(l);
+      m_pimpl = BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(l);
       return result;
    }
    locale_type getloc()const
@@ -1001,7 +1056,7 @@ public:
    static std::string get_catalog_name();
 
 private:
-   boost::shared_ptr<const re_detail::cpp_regex_traits_implementation<charT> > m_pimpl;
+   boost::shared_ptr<const BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT> > m_pimpl;
    //
    // catalog name handler:
    //
@@ -1016,7 +1071,7 @@ private:
 template <class charT>
 int cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const
 {
-   re_detail::parser_buf<charT>   sbuf;            // buffer for parsing numbers.
+   BOOST_REGEX_DETAIL_NS::parser_buf<charT>   sbuf;            // buffer for parsing numbers.
    std::basic_istream<charT>      is(&sbuf);       // stream for parsing numbers.
 
    // we do NOT want to parse any thousands separators inside the stream: