Merge bug fixes from Trunk - see history for full details.

[SVN r58234]

src/cpp_regex_traits.cpp

@@ -42,7 +42,7 @@ void cpp_regex_traits_char_layer<char>::init()
    std::messages<char>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1);
 #endif
    std::string cat_name(cpp_regex_traits<char>::get_catalog_name());
-   if(cat_name.size())
+   if(cat_name.size() && (m_pmessages != 0))
    {
       cat = this->m_pmessages->open(
          cat_name, 

src/cregex.cpp

@@ -563,11 +563,7 @@ std::string RegEx::What(int i)const
    return result;
 }
 
-#ifdef BOOST_HAS_LONG_LONG
-const std::size_t RegEx::npos = static_cast<std::size_t>(~0ULL);
-#else
-const std::size_t RegEx::npos = static_cast<std::size_t>(~0UL);
-#endif
+const std::size_t RegEx::npos = ~static_cast<std::size_t>(0);
 
 } // namespace boost
 

src/fileiter.cpp

@@ -258,11 +258,22 @@ void mapfile::lock(pointer* node)const
             *p = 0;
             *(reinterpret_cast<int*>(*node)) = 1;
          }
-         std::fseek(hfile, (node - _first) * buf_size, SEEK_SET);
-         if(node == _last - 1)
-            std::fread(*node + sizeof(int), _size % buf_size, 1, hfile);
-         else
-            std::fread(*node + sizeof(int), buf_size, 1, hfile);
+ 
+        std::size_t read_size = 0; 
+        int read_pos = std::fseek(hfile, (node - _first) * buf_size, SEEK_SET); 
+
+        if(0 == read_pos && node == _last - 1) 
+           read_size = std::fread(*node + sizeof(int), _size % buf_size, 1, hfile); 
+        else
+           read_size = std::fread(*node + sizeof(int), buf_size, 1, hfile);
+#ifndef BOOST_NO_EXCEPTIONS 
+        if((read_size == 0) || (std::ferror(hfile)))
+        { 
+           throw std::runtime_error("Unable to read file."); 
+        } 
+#else 
+        BOOST_REGEX_NOEH_ASSERT((0 == std::ferror(hfile)) && (read_size != 0)); 
+#endif 
       }
       else
       {

src/posix_api.cpp

@@ -58,6 +58,7 @@ const char* names[] = {
       "REG_EMPTY",
       "REG_ECOMPLEXITY",
       "REG_ESTACK",
+      "REG_E_PERL",
       "REG_E_UNKNOWN",
 };
 } // namespace

src/regex_traits_defaults.cpp

@@ -111,30 +111,31 @@ BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants
 BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_constants::error_type n)
 {
    static const char* const s_default_error_messages[] = {
-      "Success",             /* REG_NOERROR */
-      "No match",             /* REG_NOMATCH */
-      "Invalid regular expression",    /* REG_BADPAT */
-      "Invalid collation character",      /* REG_ECOLLATE */
-      "Invalid character class name",     /* REG_ECTYPE */
-      "Invalid or trailing backslash",         /* REG_EESCAPE */
-      "Invalid back reference",        /* REG_ESUBREG */
-      "Unmatched [ or [^",       /* REG_EBRACK */
-      "Unmatched ( or \\(",         /* REG_EPAREN */
-      "Unmatched { or \\{",           /* REG_EBRACE */
-      "Invalid content of repeat range",     /* REG_BADBR */
-      "Invalid range end",       /* REG_ERANGE */
-      "Memory exhausted",           /* REG_ESPACE */
-      "Invalid preceding regular expression",   /* REG_BADRPT */
-      "Premature end of regular expression", /* REG_EEND */
-      "Regular expression too big",    /* REG_ESIZE */
-      "Unmatched ) or \\)",         /* REG_ERPAREN */
-      "Empty expression",           /* REG_EMPTY */
-      "Complexity requirements exceeded",  /* REG_ECOMPLEXITY */
-      "Out of stack space", /* REG_ESTACK */
-      "Unknown error",    /* REG_E_UNKNOWN */
-      "",
-      "",
-      "",
+      "Success",                                                            /* REG_NOERROR 0 error_ok */
+      "No match",                                                           /* REG_NOMATCH 1 error_no_match */
+      "Invalid regular expression.",                                        /* REG_BADPAT 2 error_bad_pattern */
+      "Invalid collation character.",                                       /* REG_ECOLLATE 3 error_collate */
+      "Invalid character class name, collating name, or character range.",  /* REG_ECTYPE 4 error_ctype */
+      "Invalid or unterminated escape sequence.",                           /* REG_EESCAPE 5 error_escape */
+      "Invalid back reference: specified capturing group does not exist.",  /* REG_ESUBREG 6 error_backref */
+      "Unmatched [ or [^ in character class declaration.",                  /* REG_EBRACK 7 error_brack */
+      "Unmatched marking parenthesis ( or \\(.",                            /* REG_EPAREN 8 error_paren */
+      "Unmatched quantified repeat operator { or \\{.",                     /* REG_EBRACE 9 error_brace */
+      "Invalid content of repeat range.",                                   /* REG_BADBR 10 error_badbrace */
+      "Invalid range end in character class",                               /* REG_ERANGE 11 error_range */
+      "Out of memory.",                                                     /* REG_ESPACE 12 error_space NOT USED */
+      "Invalid preceding regular expression prior to repetition operator.", /* REG_BADRPT 13 error_badrepeat */
+      "Premature end of regular expression",                                /* REG_EEND 14 error_end NOT USED */
+      "Regular expression is too large.",                                   /* REG_ESIZE 15 error_size NOT USED */
+      "Unmatched ) or \\)",                                                 /* REG_ERPAREN 16 error_right_paren NOT USED */
+      "Empty regular expression.",                                          /* REG_EMPTY 17 error_empty */
+      "The complexity of matching the regular expression exceeded predefined bounds.  "
+      "Try refactoring the regular expression to make each choice made by the state machine unambiguous.  "
+      "This exception is thrown to prevent \"eternal\" matches that take an "
+      "indefinite period time to locate.",                                  /* REG_ECOMPLEXITY 18 error_complexity */
+      "Ran out of stack space trying to match the regular expression.",     /* REG_ESTACK 19 error_stack */
+      "Invalid or unterminated Perl (?...) sequence.",                      /* REG_E_PERL 20 error_perl */
+      "Unknown error.",                                                     /* REG_E_UNKNOWN 21 error_unknown */
    };
 
    return (n > ::boost::regex_constants::error_unknown) ? s_default_error_messages[ ::boost::regex_constants::error_unknown] : s_default_error_messages[n];

src/static_mutex.cpp

@@ -157,7 +157,7 @@ void scoped_static_mutex_lock::lock()
    {
        boost::call_once(static_mutex::m_once,&static_mutex::init);
       if(0 == m_plock)
-         m_plock = new boost::recursive_mutex::scoped_lock(*static_mutex::m_pmutex, false);
+         m_plock = new boost::recursive_mutex::scoped_lock(*static_mutex::m_pmutex, boost::defer_lock);
       m_plock->lock();
       m_have_lock = true;
    }

src/usinstances.cpp

@@ -17,6 +17,9 @@
   */
 
 #define BOOST_REGEX_SOURCE
+#ifdef _MSC_VER
+#pragma warning(disable:4506) // 'no definition for inline function'
+#endif
 
 #include <boost/detail/workaround.hpp>
 #include <memory>

src/wide_posix_api.cpp

@@ -65,6 +65,7 @@ const wchar_t* wnames[] = {
       L"REG_EMPTY",
       L"REG_ECOMPLEXITY",
       L"REG_ESTACK",
+      L"REG_E_PERL",
       L"REG_E_UNKNOWN",
 };
 }