passenger 6.0.4 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/regex_token_iterator.hpp

@@ -0,0 +1,255 @@
+/*
+ *
+ * Copyright (c) 2003
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to 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)
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_token_iterator.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Provides regex_token_iterator implementation.
+  */
+
+#ifndef BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
+#define BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
+
+#include <memory>
+
+namespace boost{
+
+template <class BidirectionalIterator,
+          class charT,
+          class traits>
+class regex_token_iterator_implementation 
+{
+   typedef basic_regex<charT, traits> regex_type;
+   typedef sub_match<BidirectionalIterator>      value_type;
+
+   match_results<BidirectionalIterator> what;   // current match
+   BidirectionalIterator                base;    // start of search area
+   BidirectionalIterator                end;    // end of search area
+   const regex_type                     re;    // the expression
+   match_flag_type                      flags;  // match flags
+   value_type                           result; // the current string result
+   int                                  N;      // the current sub-expression being enumerated
+   std::vector<int>                     subs;   // the sub-expressions to enumerate
+
+public:
+   regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)
+      : end(last), re(*p), flags(f), N(0){ subs.push_back(sub); }
+   regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)
+      : end(last), re(*p), flags(f), N(0), subs(v){}
+   template <std::size_t CN>
+   regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const int (&submatches)[CN], match_flag_type f)
+      : end(last), re(*p), flags(f), N(0)
+   {
+      for(std::size_t i = 0; i < CN; ++i)
+      {
+         subs.push_back(submatches[i]);
+      }
+   }
+   regex_token_iterator_implementation(const regex_token_iterator_implementation& other) = default;
+   bool init(BidirectionalIterator first)
+   {
+      N = 0;
+      base = first;
+      if(regex_search(first, end, what, re, flags, base) == true)
+      {
+         N = 0;
+         result = ((subs[N] == -1) ? what.prefix() : what[(int)subs[N]]);
+         return true;
+      }
+      else if((subs[N] == -1) && (first != end))
+      {
+         result.first = first;
+         result.second = end;
+         result.matched = (first != end);
+         N = -1;
+         return true;
+      }
+      return false;
+   }
+   bool compare(const regex_token_iterator_implementation& that)
+   {
+      if(this == &that) return true;
+      return (&re.get_data() == &that.re.get_data()) 
+         && (end == that.end) 
+         && (flags == that.flags) 
+         && (N == that.N) 
+         && (what[0].first == that.what[0].first) 
+         && (what[0].second == that.what[0].second);
+   }
+   const value_type& get()
+   { return result; }
+   bool next()
+   {
+      if(N == -1)
+         return false;
+      if(N+1 < (int)subs.size())
+      {
+         ++N;
+         result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
+         return true;
+      }
+      //if(what.prefix().first != what[0].second)
+      //   flags |= /*match_prev_avail |*/ regex_constants::match_not_bob;
+      BidirectionalIterator last_end(what[0].second);
+      if(regex_search(last_end, end, what, re, ((what[0].first == what[0].second) ? flags | regex_constants::match_not_initial_null : flags), base))
+      {
+         N =0;
+         result =((subs[N] == -1) ? what.prefix() : what[subs[N]]);
+         return true;
+      }
+      else if((last_end != end) && (subs[0] == -1))
+      {
+         N =-1;
+         result.first = last_end;
+         result.second = end;
+         result.matched = (last_end != end);
+         return true;
+      }
+      return false;
+   }
+private:
+   regex_token_iterator_implementation& operator=(const regex_token_iterator_implementation&);
+};
+
+template <class BidirectionalIterator, 
+          class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
+          class traits = regex_traits<charT> >
+class regex_token_iterator 
+{
+private:
+   typedef regex_token_iterator_implementation<BidirectionalIterator, charT, traits> impl;
+   typedef std::shared_ptr<impl> pimpl;
+public:
+   typedef          basic_regex<charT, traits>                   regex_type;
+   typedef          sub_match<BidirectionalIterator>                        value_type;
+   typedef typename std::iterator_traits<BidirectionalIterator>::difference_type 
+                                                                            difference_type;
+   typedef          const value_type*                                       pointer;
+   typedef          const value_type&                                       reference; 
+   typedef          std::forward_iterator_tag                               iterator_category;
+   
+   regex_token_iterator(){}
+   regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, 
+                        int submatch = 0, match_flag_type m = match_default)
+                        : pdata(new impl(&re, b, submatch, m))
+   {
+      if(!pdata->init(a))
+         pdata.reset();
+   }
+   regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, 
+                        const std::vector<int>& submatches, match_flag_type m = match_default)
+                        : pdata(new impl(&re, b, submatches, m))
+   {
+      if(!pdata->init(a))
+         pdata.reset();
+   }
+   template <std::size_t N>
+   regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,
+                        const int (&submatches)[N], match_flag_type m = match_default)
+                        : pdata(new impl(&re, b, submatches, m))
+   {
+      if(!pdata->init(a))
+         pdata.reset();
+   }
+   regex_token_iterator(const regex_token_iterator& that)
+      : pdata(that.pdata) {}
+   regex_token_iterator& operator=(const regex_token_iterator& that)
+   {
+      pdata = that.pdata;
+      return *this;
+   }
+   bool operator==(const regex_token_iterator& that)const
+   { 
+      if((pdata.get() == 0) || (that.pdata.get() == 0))
+         return pdata.get() == that.pdata.get();
+      return pdata->compare(*(that.pdata.get())); 
+   }
+   bool operator!=(const regex_token_iterator& that)const
+   { return !(*this == that); }
+   const value_type& operator*()const
+   { return pdata->get(); }
+   const value_type* operator->()const
+   { return &(pdata->get()); }
+   regex_token_iterator& operator++()
+   {
+      cow();
+      if(0 == pdata->next())
+      {
+         pdata.reset();
+      }
+      return *this;
+   }
+   regex_token_iterator operator++(int)
+   {
+      regex_token_iterator result(*this);
+      ++(*this);
+      return result;
+   }
+private:
+
+   pimpl pdata;
+
+   void cow()
+   {
+      // copy-on-write
+      if(pdata.get() && (pdata.use_count() > 1))
+      {
+         pdata.reset(new impl(*(pdata.get())));
+      }
+   }
+};
+
+typedef regex_token_iterator<const char*> cregex_token_iterator;
+typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
+#ifndef BOOST_NO_WREGEX
+typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
+#endif
+
+template <class charT, class traits>
+inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
+}
+template <class charT, class traits, class ST, class SA>
+inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
+}
+template <class charT, class traits, std::size_t N>
+inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
+}
+template <class charT, class traits, class ST, class SA, std::size_t N>
+inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
+}
+template <class charT, class traits>
+inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
+}
+template <class charT, class traits, class ST, class SA>
+inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
+{
+   return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
+}
+
+} // namespace boost
+
+#endif // BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
+
+
+
+

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/regex_traits.hpp

@@ -0,0 +1,130 @@
+/*
+ *
+ * Copyright (c) 2003
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to 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)
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_traits.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares regular expression traits classes.
+  */
+
+#ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED
+#define BOOST_REGEX_TRAITS_HPP_INCLUDED
+
+#include <boost/regex/config.hpp>
+#include <boost/regex/v5/regex_workaround.hpp>
+#include <boost/regex/v5/syntax_type.hpp>
+#include <boost/regex/v5/error_type.hpp>
+#include <boost/regex/v5/regex_traits_defaults.hpp>
+#include <boost/regex/v5/cpp_regex_traits.hpp>
+#include <boost/regex/v5/c_regex_traits.hpp>
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+#     include <boost/regex/v5/w32_regex_traits.hpp>
+#endif
+#include <boost/regex_fwd.hpp>
+
+namespace boost{
+
+template <class charT, class implementationT >
+struct regex_traits : public implementationT
+{
+   regex_traits() : implementationT() {}
+};
+
+//
+// class regex_traits_wrapper.
+// this is what our implementation will actually store;
+// it provides default implementations of the "optional"
+// interfaces that we support, in addition to the
+// required "standard" ones:
+//
+namespace BOOST_REGEX_DETAIL_NS{
+
+   template <class T>
+   struct has_boost_extensions_tag
+   {
+      template <class U>
+      static double checker(U*, typename U::boost_extensions_tag* = nullptr);
+      static char   checker(...);
+      static T* get();
+
+      static const bool value = sizeof(checker(get())) > 1;
+   };
+   
+
+template <class BaseT>
+struct default_wrapper : public BaseT
+{
+   typedef typename BaseT::char_type char_type;
+   std::string error_string(::boost::regex_constants::error_type e)const
+   {
+      return ::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(e);
+   }
+   ::boost::regex_constants::syntax_type syntax_type(char_type c)const
+   {
+      return (char_type(c & 0x7f) == c) ? get_default_syntax_type(static_cast<char>(c)) : ::boost::regex_constants::syntax_char;
+   }
+   ::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c)const
+   {
+      return (char_type(c & 0x7f) == c) ? get_default_escape_syntax_type(static_cast<char>(c)) : ::boost::regex_constants::escape_type_identity;
+   }
+   std::intmax_t toi(const char_type*& p1, const char_type* p2, int radix)const
+   {
+      return ::boost::BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
+   }
+   char_type translate(char_type c, bool icase)const
+   {
+      return (icase ? this->translate_nocase(c) : this->translate(c));
+   }
+   char_type translate(char_type c)const
+   {
+      return BaseT::translate(c);
+   }
+   char_type tolower(char_type c)const
+   {
+      return ::boost::BOOST_REGEX_DETAIL_NS::global_lower(c);
+   }
+   char_type toupper(char_type c)const
+   {
+      return ::boost::BOOST_REGEX_DETAIL_NS::global_upper(c);
+   }
+};
+
+template <class BaseT, bool has_extensions>
+struct compute_wrapper_base
+{
+   typedef BaseT type;
+};
+template <class BaseT>
+struct compute_wrapper_base<BaseT, false>
+{
+   typedef default_wrapper<BaseT> type;
+};
+
+} // namespace BOOST_REGEX_DETAIL_NS
+
+template <class BaseT>
+struct regex_traits_wrapper 
+   : public ::boost::BOOST_REGEX_DETAIL_NS::compute_wrapper_base<
+               BaseT, 
+               ::boost::BOOST_REGEX_DETAIL_NS::has_boost_extensions_tag<BaseT>::value
+            >::type
+{
+   regex_traits_wrapper(){}
+private:
+   regex_traits_wrapper(const regex_traits_wrapper&);
+   regex_traits_wrapper& operator=(const regex_traits_wrapper&);
+};
+
+} // namespace boost
+
+#endif // include
+

data/src/cxx_supportlib/vendor-modified/boost/{libs/regex/src/regex_traits_defaults.cpp → regex/v5/regex_traits_defaults.hpp}

@@ -3,42 +3,50 @@
  * Copyright (c) 2004
  * John Maddock
  *
- * Use, modification and distribution are subject to the 
- * Boost Software License, Version 1.0. (See accompanying file 
+ * Use, modification and distribution are subject to 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)
  *
  */
- 
+
  /*
   *   LOCATION:    see http://www.boost.org for most recent version.
-  *   FILE         regex_traits_defaults.cpp
+  *   FILE         regex_traits_defaults.hpp
   *   VERSION      see <boost/version.hpp>
   *   DESCRIPTION: Declares API's for access to regex_traits default properties.
   */
 
-#define BOOST_REGEX_SOURCE
-#include <boost/regex/regex_traits.hpp>
+#ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
+#define BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
+
+#include <boost/regex/config.hpp>
 
+#include <boost/regex/v5/syntax_type.hpp>
+#include <boost/regex/v5/error_type.hpp>
+#include <boost/regex/v5/regex_workaround.hpp>
+#include <type_traits>
+#include <cstdint>
 #include <cctype>
-#ifndef BOOST_NO_WREGEX
+#include <locale>
 #include <cwctype>
-#endif
+#include <limits>
 
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-   using ::tolower;
-   using ::toupper;
-#ifndef BOOST_NO_WREGEX
-   using ::towlower;
-   using ::towupper;
-#endif
-}
-#endif
+namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
 
 
-namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
+//
+// helpers to suppress warnings:
+//
+template <class charT>
+inline bool is_extended(charT c)
+{
+   typedef typename std::make_unsigned<charT>::type unsigned_type; 
+   return (sizeof(charT) > 1) && (static_cast<unsigned_type>(c) >= 256u); 
+}
+inline bool is_extended(char)
+{ return false; }
 
-BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n)
+inline const char*  get_default_syntax(regex_constants::syntax_type n)
 {
    // if the user hasn't supplied a message catalog, then this supplies
    // default "messages" for us to load in the range 1-100.
@@ -108,7 +116,7 @@ BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants
    return ((n >= (sizeof(messages) / sizeof(messages[1]))) ? "" : messages[n]);
 }
 
-BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_constants::error_type n)
+inline const char*  get_default_error_string(regex_constants::error_type n)
 {
    static const char* const s_default_error_messages[] = {
       "Success",                                                            /* REG_NOERROR 0 error_ok */
@@ -138,407 +146,56 @@ BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_con
       "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];
-}
-
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining_implementation(boost::uint_least16_t c)
-{
-   const boost::uint_least16_t combining_ranges[] = { 0x0300, 0x0361, 
-                           0x0483, 0x0486, 
-                           0x0903, 0x0903, 
-                           0x093E, 0x0940, 
-                           0x0949, 0x094C,
-                           0x0982, 0x0983,
-                           0x09BE, 0x09C0,
-                           0x09C7, 0x09CC,
-                           0x09D7, 0x09D7,
-                           0x0A3E, 0x0A40,
-                           0x0A83, 0x0A83,
-                           0x0ABE, 0x0AC0,
-                           0x0AC9, 0x0ACC,
-                           0x0B02, 0x0B03,
-                           0x0B3E, 0x0B3E,
-                           0x0B40, 0x0B40,
-                           0x0B47, 0x0B4C,
-                           0x0B57, 0x0B57,
-                           0x0B83, 0x0B83,
-                           0x0BBE, 0x0BBF,
-                           0x0BC1, 0x0BCC,
-                           0x0BD7, 0x0BD7,
-                           0x0C01, 0x0C03,
-                           0x0C41, 0x0C44,
-                           0x0C82, 0x0C83,
-                           0x0CBE, 0x0CBE,
-                           0x0CC0, 0x0CC4,
-                           0x0CC7, 0x0CCB,
-                           0x0CD5, 0x0CD6,
-                           0x0D02, 0x0D03,
-                           0x0D3E, 0x0D40,
-                           0x0D46, 0x0D4C,
-                           0x0D57, 0x0D57,
-                           0x0F7F, 0x0F7F,
-                           0x20D0, 0x20E1, 
-                           0x3099, 0x309A,
-                           0xFE20, 0xFE23, 
-                           0xffff, 0xffff, };
-
-      const boost::uint_least16_t* p = combining_ranges + 1;
-   while(*p < c) p += 2;
-   --p;
-   if((c >= *p) && (c <= *(p+1)))
-         return true;
-   return false;
-}
-
-//
-// these are the POSIX collating names:
-//
-BOOST_REGEX_DECL const char* def_coll_names[] = {
-"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline", 
-"vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", 
-"SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark", 
-"quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe", 
-"left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen", 
-"period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", 
-"colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign", 
-"question-mark", "commercial-at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", 
-"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "left-square-bracket", "backslash", 
-"right-square-bracket", "circumflex", "underscore", "grave-accent", "a", "b", "c", "d", "e", "f", 
-"g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "left-curly-bracket", 
-"vertical-line", "right-curly-bracket", "tilde", "DEL", "", 
-};
-
-// these multi-character collating elements
-// should keep most Western-European locales
-// happy - we should really localise these a
-// little more - but this will have to do for
-// now:
-
-BOOST_REGEX_DECL const char* def_multi_coll[] = {
-   "ae",
-   "Ae",
-   "AE",
-   "ch",
-   "Ch",
-   "CH",
-   "ll",
-   "Ll",
-   "LL",
-   "ss",
-   "Ss",
-   "SS",
-   "nj",
-   "Nj",
-   "NJ",
-   "dz",
-   "Dz",
-   "DZ",
-   "lj",
-   "Lj",
-   "LJ",
-   "",
-};
-
-
-
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name)
-{
-   unsigned int i = 0;
-   while(*def_coll_names[i])
-   {
-      if(def_coll_names[i] == name)
-      {
-         return std::string(1, char(i));
-      }
-      ++i;
-   }
-   i = 0;
-   while(*def_multi_coll[i])
-   {
-      if(def_multi_coll[i] == name)
-      {
-         return def_multi_coll[i];
-      }
-      ++i;
-   }
-   return std::string();
-}
-
-BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_lower(char c)
-{
-   return static_cast<char>((std::tolower)((unsigned char)c));
-}
-
-BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_upper(char c)
-{
-   return static_cast<char>((std::toupper)((unsigned char)c));
-}
-#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_lower(wchar_t c)
-{
-   return (std::towlower)(c);
-}
-
-BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c)
-{
-   return (std::towupper)(c);
-}
-#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_lower(unsigned short c)
-{
-   return (std::towlower)(c);
-}
-
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short c)
-{
-   return (std::towupper)(c);
+   return (n > ::boost::regex_constants::error_unknown) ? s_default_error_messages[::boost::regex_constants::error_unknown] : s_default_error_messages[n];
 }
-#endif
-
-#endif
 
-BOOST_REGEX_DECL regex_constants::escape_syntax_type BOOST_REGEX_CALL get_default_escape_syntax_type(char c)
+inline regex_constants::syntax_type  get_default_syntax_type(char c)
 {
    //
    // char_syntax determines how the compiler treats a given character
    // in a regular expression.
    //
-   static regex_constants::escape_syntax_type char_syntax[] = {
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,     /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /* */    // 32
-      regex_constants::escape_type_identity,        /*!*/
-      regex_constants::escape_type_identity,        /*"*/
-      regex_constants::escape_type_identity,        /*#*/
-      regex_constants::escape_type_identity,        /*$*/
-      regex_constants::escape_type_identity,        /*%*/
-      regex_constants::escape_type_identity,        /*&*/
-      regex_constants::escape_type_end_buffer,        /*'*/
-      regex_constants::syntax_open_mark,        /*(*/
-      regex_constants::syntax_close_mark,        /*)*/
-      regex_constants::escape_type_identity,        /***/
-      regex_constants::syntax_plus,                 /*+*/
-      regex_constants::escape_type_identity,        /*,*/
-      regex_constants::escape_type_identity,        /*-*/
-      regex_constants::escape_type_identity,        /*.*/
-      regex_constants::escape_type_identity,        /*/*/
-      regex_constants::escape_type_decimal,        /*0*/
-      regex_constants::escape_type_backref,        /*1*/
-      regex_constants::escape_type_backref,        /*2*/
-      regex_constants::escape_type_backref,        /*3*/
-      regex_constants::escape_type_backref,        /*4*/
-      regex_constants::escape_type_backref,        /*5*/
-      regex_constants::escape_type_backref,        /*6*/
-      regex_constants::escape_type_backref,        /*7*/
-      regex_constants::escape_type_backref,        /*8*/
-      regex_constants::escape_type_backref,        /*9*/
-      regex_constants::escape_type_identity,        /*:*/
-      regex_constants::escape_type_identity,        /*;*/
-      regex_constants::escape_type_left_word,        /*<*/
-      regex_constants::escape_type_identity,        /*=*/
-      regex_constants::escape_type_right_word,        /*>*/
-      regex_constants::syntax_question,              /*?*/
-      regex_constants::escape_type_identity,         /*@*/
-      regex_constants::escape_type_start_buffer,     /*A*/
-      regex_constants::escape_type_not_word_assert,  /*B*/
-      regex_constants::escape_type_C,                /*C*/
-      regex_constants::escape_type_not_class,        /*D*/
-      regex_constants::escape_type_E,                /*E*/
-      regex_constants::escape_type_not_class,        /*F*/
-      regex_constants::escape_type_G,                /*G*/
-      regex_constants::escape_type_not_class,        /*H*/
-      regex_constants::escape_type_not_class,        /*I*/
-      regex_constants::escape_type_not_class,        /*J*/
-      regex_constants::escape_type_reset_start_mark, /*K*/
-      regex_constants::escape_type_not_class,        /*L*/
-      regex_constants::escape_type_not_class,        /*M*/
-      regex_constants::escape_type_named_char,       /*N*/
-      regex_constants::escape_type_not_class,        /*O*/
-      regex_constants::escape_type_not_property,     /*P*/
-      regex_constants::escape_type_Q,                /*Q*/
-      regex_constants::escape_type_line_ending,      /*R*/
-      regex_constants::escape_type_not_class,        /*S*/
-      regex_constants::escape_type_not_class,        /*T*/
-      regex_constants::escape_type_not_class,        /*U*/
-      regex_constants::escape_type_not_class,        /*V*/
-      regex_constants::escape_type_not_class,        /*W*/
-      regex_constants::escape_type_X,                /*X*/
-      regex_constants::escape_type_not_class,        /*Y*/
-      regex_constants::escape_type_Z,                /*Z*/
-      regex_constants::escape_type_identity,        /*[*/
-      regex_constants::escape_type_identity,        /*\*/
-      regex_constants::escape_type_identity,        /*]*/
-      regex_constants::escape_type_identity,        /*^*/
-      regex_constants::escape_type_identity,        /*_*/
-      regex_constants::escape_type_start_buffer,        /*`*/
-      regex_constants::escape_type_control_a,        /*a*/
-      regex_constants::escape_type_word_assert,        /*b*/
-      regex_constants::escape_type_ascii_control,        /*c*/
-      regex_constants::escape_type_class,        /*d*/
-      regex_constants::escape_type_e,        /*e*/
-      regex_constants::escape_type_control_f,       /*f*/
-      regex_constants::escape_type_extended_backref,  /*g*/
-      regex_constants::escape_type_class,        /*h*/
-      regex_constants::escape_type_class,        /*i*/
-      regex_constants::escape_type_class,        /*j*/
-      regex_constants::escape_type_extended_backref, /*k*/
-      regex_constants::escape_type_class,        /*l*/
-      regex_constants::escape_type_class,        /*m*/
-      regex_constants::escape_type_control_n,       /*n*/
-      regex_constants::escape_type_class,           /*o*/
-      regex_constants::escape_type_property,        /*p*/
-      regex_constants::escape_type_class,           /*q*/
-      regex_constants::escape_type_control_r,       /*r*/
-      regex_constants::escape_type_class,           /*s*/
-      regex_constants::escape_type_control_t,       /*t*/
-      regex_constants::escape_type_class,         /*u*/
-      regex_constants::escape_type_control_v,       /*v*/
-      regex_constants::escape_type_class,           /*w*/
-      regex_constants::escape_type_hex,             /*x*/
-      regex_constants::escape_type_class,           /*y*/
-      regex_constants::escape_type_end_buffer,      /*z*/
-      regex_constants::syntax_open_brace,           /*{*/
-      regex_constants::syntax_or,                   /*|*/
-      regex_constants::syntax_close_brace,          /*}*/
-      regex_constants::escape_type_identity,        /*~*/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-      regex_constants::escape_type_identity,        /**/
-   };
-
-   return char_syntax[(unsigned char)c];
-}
-
-BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_syntax_type(char c)
-{
-   //
-   // char_syntax determines how the compiler treats a given character
-   // in a regular expression.
-   //
-   static regex_constants::syntax_type char_syntax[] = {
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_newline,     /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /**/
-      regex_constants::syntax_char,        /* */    // 32
-      regex_constants::syntax_not,        /*!*/
-      regex_constants::syntax_char,        /*"*/
-      regex_constants::syntax_hash,        /*#*/
-      regex_constants::syntax_dollar,        /*$*/
-      regex_constants::syntax_char,        /*%*/
-      regex_constants::syntax_char,        /*&*/
-      regex_constants::escape_type_end_buffer,  /*'*/
+   static regex_constants::syntax_type char_syntax[] = {
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_newline,     /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /**/
+      regex_constants::syntax_char,        /* */    // 32
+      regex_constants::syntax_not,        /*!*/
+      regex_constants::syntax_char,        /*"*/
+      regex_constants::syntax_hash,        /*#*/
+      regex_constants::syntax_dollar,        /*$*/
+      regex_constants::syntax_char,        /*%*/
+      regex_constants::syntax_char,        /*&*/
+      regex_constants::escape_type_end_buffer,  /*'*/
       regex_constants::syntax_open_mark,        /*(*/
       regex_constants::syntax_close_mark,        /*)*/
       regex_constants::syntax_star,        /***/
@@ -687,6 +344,653 @@ BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_synta
    return char_syntax[(unsigned char)c];
 }
 
+inline regex_constants::escape_syntax_type  get_default_escape_syntax_type(char c)
+{
+   //
+   // char_syntax determines how the compiler treats a given character
+   // in a regular expression.
+   //
+   static regex_constants::escape_syntax_type char_syntax[] = {
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,     /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /* */    // 32
+      regex_constants::escape_type_identity,        /*!*/
+      regex_constants::escape_type_identity,        /*"*/
+      regex_constants::escape_type_identity,        /*#*/
+      regex_constants::escape_type_identity,        /*$*/
+      regex_constants::escape_type_identity,        /*%*/
+      regex_constants::escape_type_identity,        /*&*/
+      regex_constants::escape_type_end_buffer,        /*'*/
+      regex_constants::syntax_open_mark,        /*(*/
+      regex_constants::syntax_close_mark,        /*)*/
+      regex_constants::escape_type_identity,        /***/
+      regex_constants::syntax_plus,                 /*+*/
+      regex_constants::escape_type_identity,        /*,*/
+      regex_constants::escape_type_identity,        /*-*/
+      regex_constants::escape_type_identity,        /*.*/
+      regex_constants::escape_type_identity,        /*/*/
+      regex_constants::escape_type_decimal,        /*0*/
+      regex_constants::escape_type_backref,        /*1*/
+      regex_constants::escape_type_backref,        /*2*/
+      regex_constants::escape_type_backref,        /*3*/
+      regex_constants::escape_type_backref,        /*4*/
+      regex_constants::escape_type_backref,        /*5*/
+      regex_constants::escape_type_backref,        /*6*/
+      regex_constants::escape_type_backref,        /*7*/
+      regex_constants::escape_type_backref,        /*8*/
+      regex_constants::escape_type_backref,        /*9*/
+      regex_constants::escape_type_identity,        /*:*/
+      regex_constants::escape_type_identity,        /*;*/
+      regex_constants::escape_type_left_word,        /*<*/
+      regex_constants::escape_type_identity,        /*=*/
+      regex_constants::escape_type_right_word,        /*>*/
+      regex_constants::syntax_question,              /*?*/
+      regex_constants::escape_type_identity,         /*@*/
+      regex_constants::escape_type_start_buffer,     /*A*/
+      regex_constants::escape_type_not_word_assert,  /*B*/
+      regex_constants::escape_type_C,                /*C*/
+      regex_constants::escape_type_not_class,        /*D*/
+      regex_constants::escape_type_E,                /*E*/
+      regex_constants::escape_type_not_class,        /*F*/
+      regex_constants::escape_type_G,                /*G*/
+      regex_constants::escape_type_not_class,        /*H*/
+      regex_constants::escape_type_not_class,        /*I*/
+      regex_constants::escape_type_not_class,        /*J*/
+      regex_constants::escape_type_reset_start_mark, /*K*/
+      regex_constants::escape_type_not_class,        /*L*/
+      regex_constants::escape_type_not_class,        /*M*/
+      regex_constants::escape_type_named_char,       /*N*/
+      regex_constants::escape_type_not_class,        /*O*/
+      regex_constants::escape_type_not_property,     /*P*/
+      regex_constants::escape_type_Q,                /*Q*/
+      regex_constants::escape_type_line_ending,      /*R*/
+      regex_constants::escape_type_not_class,        /*S*/
+      regex_constants::escape_type_not_class,        /*T*/
+      regex_constants::escape_type_not_class,        /*U*/
+      regex_constants::escape_type_not_class,        /*V*/
+      regex_constants::escape_type_not_class,        /*W*/
+      regex_constants::escape_type_X,                /*X*/
+      regex_constants::escape_type_not_class,        /*Y*/
+      regex_constants::escape_type_Z,                /*Z*/
+      regex_constants::escape_type_identity,        /*[*/
+      regex_constants::escape_type_identity,        /*\*/
+      regex_constants::escape_type_identity,        /*]*/
+      regex_constants::escape_type_identity,        /*^*/
+      regex_constants::escape_type_identity,        /*_*/
+      regex_constants::escape_type_start_buffer,        /*`*/
+      regex_constants::escape_type_control_a,        /*a*/
+      regex_constants::escape_type_word_assert,        /*b*/
+      regex_constants::escape_type_ascii_control,        /*c*/
+      regex_constants::escape_type_class,        /*d*/
+      regex_constants::escape_type_e,        /*e*/
+      regex_constants::escape_type_control_f,       /*f*/
+      regex_constants::escape_type_extended_backref,  /*g*/
+      regex_constants::escape_type_class,        /*h*/
+      regex_constants::escape_type_class,        /*i*/
+      regex_constants::escape_type_class,        /*j*/
+      regex_constants::escape_type_extended_backref, /*k*/
+      regex_constants::escape_type_class,        /*l*/
+      regex_constants::escape_type_class,        /*m*/
+      regex_constants::escape_type_control_n,       /*n*/
+      regex_constants::escape_type_class,           /*o*/
+      regex_constants::escape_type_property,        /*p*/
+      regex_constants::escape_type_class,           /*q*/
+      regex_constants::escape_type_control_r,       /*r*/
+      regex_constants::escape_type_class,           /*s*/
+      regex_constants::escape_type_control_t,       /*t*/
+      regex_constants::escape_type_class,         /*u*/
+      regex_constants::escape_type_control_v,       /*v*/
+      regex_constants::escape_type_class,           /*w*/
+      regex_constants::escape_type_hex,             /*x*/
+      regex_constants::escape_type_class,           /*y*/
+      regex_constants::escape_type_end_buffer,      /*z*/
+      regex_constants::syntax_open_brace,           /*{*/
+      regex_constants::syntax_or,                   /*|*/
+      regex_constants::syntax_close_brace,          /*}*/
+      regex_constants::escape_type_identity,        /*~*/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+      regex_constants::escape_type_identity,        /**/
+   };
+
+   return char_syntax[(unsigned char)c];
+}
+
+// is charT c a combining character?
+inline bool  is_combining_implementation(std::uint_least16_t c)
+{
+   const std::uint_least16_t combining_ranges[] = { 0x0300, 0x0361,
+                           0x0483, 0x0486,
+                           0x0903, 0x0903,
+                           0x093E, 0x0940,
+                           0x0949, 0x094C,
+                           0x0982, 0x0983,
+                           0x09BE, 0x09C0,
+                           0x09C7, 0x09CC,
+                           0x09D7, 0x09D7,
+                           0x0A3E, 0x0A40,
+                           0x0A83, 0x0A83,
+                           0x0ABE, 0x0AC0,
+                           0x0AC9, 0x0ACC,
+                           0x0B02, 0x0B03,
+                           0x0B3E, 0x0B3E,
+                           0x0B40, 0x0B40,
+                           0x0B47, 0x0B4C,
+                           0x0B57, 0x0B57,
+                           0x0B83, 0x0B83,
+                           0x0BBE, 0x0BBF,
+                           0x0BC1, 0x0BCC,
+                           0x0BD7, 0x0BD7,
+                           0x0C01, 0x0C03,
+                           0x0C41, 0x0C44,
+                           0x0C82, 0x0C83,
+                           0x0CBE, 0x0CBE,
+                           0x0CC0, 0x0CC4,
+                           0x0CC7, 0x0CCB,
+                           0x0CD5, 0x0CD6,
+                           0x0D02, 0x0D03,
+                           0x0D3E, 0x0D40,
+                           0x0D46, 0x0D4C,
+                           0x0D57, 0x0D57,
+                           0x0F7F, 0x0F7F,
+                           0x20D0, 0x20E1,
+                           0x3099, 0x309A,
+                           0xFE20, 0xFE23,
+                           0xffff, 0xffff, };
+
+   const std::uint_least16_t* p = combining_ranges + 1;
+   while (*p < c) p += 2;
+   --p;
+   if ((c >= *p) && (c <= *(p + 1)))
+      return true;
+   return false;
+}
+
+template <class charT>
+inline bool is_combining(charT c)
+{
+   return (c <= static_cast<charT>(0)) ? false : ((c >= static_cast<charT>((std::numeric_limits<uint_least16_t>::max)())) ? false : is_combining_implementation(static_cast<unsigned short>(c)));
+}
+template <>
+inline bool is_combining<char>(char)
+{
+   return false;
+}
+template <>
+inline bool is_combining<signed char>(signed char)
+{
+   return false;
+}
+template <>
+inline bool is_combining<unsigned char>(unsigned char)
+{
+   return false;
+}
+#ifdef _MSC_VER
+template<>
+inline bool is_combining<wchar_t>(wchar_t c)
+{
+   return is_combining_implementation(static_cast<unsigned short>(c));
+}
+#elif !defined(__DECCXX) && !defined(__osf__) && !defined(__OSF__) && defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if defined(WCHAR_MAX) && (WCHAR_MAX <= USHRT_MAX)
+template<>
+inline bool is_combining<wchar_t>(wchar_t c)
+{
+   return is_combining_implementation(static_cast<unsigned short>(c));
+}
+#else
+template<>
+inline bool is_combining<wchar_t>(wchar_t c)
+{
+   return (c >= (std::numeric_limits<uint_least16_t>::max)()) ? false : is_combining_implementation(static_cast<unsigned short>(c));
+}
+#endif
+#endif
+
+//
+// is a charT c a line separator?
+//
+template <class charT>
+inline bool is_separator(charT c)
+{
+   return BOOST_REGEX_MAKE_BOOL(
+      (c == static_cast<charT>('\n'))
+      || (c == static_cast<charT>('\r'))
+      || (c == static_cast<charT>('\f'))
+      || (static_cast<std::uint16_t>(c) == 0x2028u)
+      || (static_cast<std::uint16_t>(c) == 0x2029u)
+      || (static_cast<std::uint16_t>(c) == 0x85u));
+}
+template <>
+inline bool is_separator<char>(char c)
+{
+   return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f'));
+}
+
+//
+// get a default collating element:
+//
+inline std::string  lookup_default_collate_name(const std::string& name)
+{
+   //
+   // these are the POSIX collating names:
+   //
+   static const char* def_coll_names[] = {
+   "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline",
+   "vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",
+   "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark",
+   "quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe",
+   "left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen",
+   "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
+   "colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign",
+   "question-mark", "commercial-at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
+   "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "left-square-bracket", "backslash",
+   "right-square-bracket", "circumflex", "underscore", "grave-accent", "a", "b", "c", "d", "e", "f",
+   "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "left-curly-bracket",
+   "vertical-line", "right-curly-bracket", "tilde", "DEL", "",
+   };
+
+   // these multi-character collating elements
+   // should keep most Western-European locales
+   // happy - we should really localise these a
+   // little more - but this will have to do for
+   // now:
+
+   static const char* def_multi_coll[] = {
+      "ae",
+      "Ae",
+      "AE",
+      "ch",
+      "Ch",
+      "CH",
+      "ll",
+      "Ll",
+      "LL",
+      "ss",
+      "Ss",
+      "SS",
+      "nj",
+      "Nj",
+      "NJ",
+      "dz",
+      "Dz",
+      "DZ",
+      "lj",
+      "Lj",
+      "LJ",
+      "",
+   };
+
+   unsigned int i = 0;
+   while (*def_coll_names[i])
+   {
+      if (def_coll_names[i] == name)
+      {
+         return std::string(1, char(i));
+      }
+      ++i;
+   }
+   i = 0;
+   while (*def_multi_coll[i])
+   {
+      if (def_multi_coll[i] == name)
+      {
+         return def_multi_coll[i];
+      }
+      ++i;
+   }
+   return std::string();
+}
+
+//
+// get the state_id of a character classification, the individual
+// traits classes then transform that state_id into a bitmask:
+//
+template <class charT>
+struct character_pointer_range
+{
+   const charT* p1;
+   const charT* p2;
+
+   bool operator < (const character_pointer_range& r)const
+   {
+      return std::lexicographical_compare(p1, p2, r.p1, r.p2);
+   }
+   bool operator == (const character_pointer_range& r)const
+   {
+      // Not only do we check that the ranges are of equal size before
+      // calling std::equal, but there is no other algorithm available:
+      // not even a non-standard MS one.  So forward to unchecked_equal
+      // in the MS case.
+#ifdef __cpp_lib_robust_nonmodifying_seq_ops
+      return std::equal(p1, p2, r.p1, r.p2);
+#elif defined(BOOST_REGEX_MSVC)
+      if (((p2 - p1) != (r.p2 - r.p1)))
+         return false;
+      const charT* with = r.p1;
+      const charT* pos = p1;
+      while (pos != p2)
+         if (*pos++ != *with++) return false;
+      return true;
+
+#else
+      return ((p2 - p1) == (r.p2 - r.p1)) && std::equal(p1, p2, r.p1);
+#endif
+   }
+};
+template <class charT>
+int get_default_class_id(const charT* p1, const charT* p2)
+{
+   static const charT data[73] = {
+      'a', 'l', 'n', 'u', 'm',
+      'a', 'l', 'p', 'h', 'a',
+      'b', 'l', 'a', 'n', 'k',
+      'c', 'n', 't', 'r', 'l',
+      'd', 'i', 'g', 'i', 't',
+      'g', 'r', 'a', 'p', 'h',
+      'l', 'o', 'w', 'e', 'r',
+      'p', 'r', 'i', 'n', 't',
+      'p', 'u', 'n', 'c', 't',
+      's', 'p', 'a', 'c', 'e',
+      'u', 'n', 'i', 'c', 'o', 'd', 'e',
+      'u', 'p', 'p', 'e', 'r',
+      'v',
+      'w', 'o', 'r', 'd',
+      'x', 'd', 'i', 'g', 'i', 't',
+   };
+
+   static const character_pointer_range<charT> ranges[21] =
+   {
+      {data+0, data+5,}, // alnum
+      {data+5, data+10,}, // alpha
+      {data+10, data+15,}, // blank
+      {data+15, data+20,}, // cntrl
+      {data+20, data+21,}, // d
+      {data+20, data+25,}, // digit
+      {data+25, data+30,}, // graph
+      {data+29, data+30,}, // h
+      {data+30, data+31,}, // l
+      {data+30, data+35,}, // lower
+      {data+35, data+40,}, // print
+      {data+40, data+45,}, // punct
+      {data+45, data+46,}, // s
+      {data+45, data+50,}, // space
+      {data+57, data+58,}, // u
+      {data+50, data+57,}, // unicode
+      {data+57, data+62,}, // upper
+      {data+62, data+63,}, // v
+      {data+63, data+64,}, // w
+      {data+63, data+67,}, // word
+      {data+67, data+73,}, // xdigit
+   };
+   const character_pointer_range<charT>* ranges_begin = ranges;
+   const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
+
+   character_pointer_range<charT> t = { p1, p2, };
+   const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);
+   if((p != ranges_end) && (t == *p))
+      return static_cast<int>(p - ranges);
+   return -1;
+}
+
+//
+// helper functions:
+//
+template <class charT>
+std::ptrdiff_t global_length(const charT* p)
+{
+   std::ptrdiff_t n = 0;
+   while(*p)
+   {
+      ++p;
+      ++n;
+   }
+   return n;
+}
+template<>
+inline std::ptrdiff_t global_length<char>(const char* p)
+{
+   return (std::strlen)(p);
+}
+#ifndef BOOST_NO_WREGEX
+template<>
+inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
+{
+   return (std::ptrdiff_t)(std::wcslen)(p);
+}
+#endif
+template <class charT>
+inline charT  global_lower(charT c)
+{
+   return c;
+}
+template <class charT>
+inline charT  global_upper(charT c)
+{
+   return c;
+}
+
+inline char  do_global_lower(char c)
+{
+   return static_cast<char>((std::tolower)((unsigned char)c));
+}
+
+inline char  do_global_upper(char c)
+{
+   return static_cast<char>((std::toupper)((unsigned char)c));
+}
+#ifndef BOOST_NO_WREGEX
+inline wchar_t  do_global_lower(wchar_t c)
+{
+   return (std::towlower)(c);
+}
+
+inline wchar_t  do_global_upper(wchar_t c)
+{
+   return (std::towupper)(c);
+}
+#endif
+//
+// This sucks: declare template specialisations of global_lower/global_upper
+// that just forward to the non-template implementation functions.  We do
+// this because there is one compiler (Compaq Tru64 C++) that doesn't seem
+// to differentiate between templates and non-template overloads....
+// what's more, the primary template, plus all overloads have to be
+// defined in the same translation unit (if one is inline they all must be)
+// otherwise the "local template instantiation" compiler option can pick
+// the wrong instantiation when linking:
+//
+template<> inline char  global_lower<char>(char c) { return do_global_lower(c); }
+template<> inline char  global_upper<char>(char c) { return do_global_upper(c); }
+#ifndef BOOST_NO_WREGEX
+template<> inline wchar_t  global_lower<wchar_t>(wchar_t c) { return do_global_lower(c); }
+template<> inline wchar_t  global_upper<wchar_t>(wchar_t c) { return do_global_upper(c); }
+#endif
+
+template <class charT>
+int global_value(charT c)
+{
+   static const charT zero = '0';
+   static const charT nine = '9';
+   static const charT a = 'a';
+   static const charT f = 'f';
+   static const charT A = 'A';
+   static const charT F = 'F';
+
+   if(c > f) return -1;
+   if(c >= a) return 10 + (c - a);
+   if(c > F) return -1;
+   if(c >= A) return 10 + (c - A);
+   if(c > nine) return -1;
+   if(c >= zero) return c - zero;
+   return -1;
+}
+template <class charT, class traits>
+std::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
+{
+   (void)t; // warning suppression
+   std::intmax_t limit = (std::numeric_limits<std::intmax_t>::max)() / radix;
+   std::intmax_t next_value = t.value(*p1, radix);
+   if((p1 == p2) || (next_value < 0) || (next_value >= radix))
+      return -1;
+   std::intmax_t result = 0;
+   while(p1 != p2)
+   {
+      next_value = t.value(*p1, radix);
+      if((next_value < 0) || (next_value >= radix))
+         break;
+      result *= radix;
+      result += next_value;
+      ++p1;
+      if (result > limit)
+         return -1;
+   }
+   return result;
+}
+
+template <class charT>
+inline typename std::enable_if<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
+{
+#ifdef BOOST_REGEX_MSVC
+#  pragma warning(push)
+#  pragma warning(disable:4309 4245)
+#endif
+   static const charT e1[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
+      '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), static_cast<charT>(0x2028),
+      static_cast<charT>(0x2029), ']', ')', ')', '\0' };
+   static const charT e2[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
+      '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), ']', ')', ')', '\0' };
+
+   charT c = static_cast<charT>(0x2029u);
+   bool b = (static_cast<unsigned>(c) == 0x2029u);
+
+   return (b ? e1 : e2);
+#ifdef BOOST_REGEX_MSVC
+#  pragma warning(pop)
+#endif
+}
+
+template <class charT>
+inline typename std::enable_if<(sizeof(charT) == 1), const charT*>::type get_escape_R_string()
+{
+#ifdef BOOST_REGEX_MSVC
+#  pragma warning(push)
+#  pragma warning(disable:4309 4245)
+#endif
+   static const charT e2[] = { 
+      static_cast<charT>('('), 
+      static_cast<charT>('?'), 
+      static_cast<charT>('-'), 
+      static_cast<charT>('x'), 
+      static_cast<charT>(':'), 
+      static_cast<charT>('('), 
+      static_cast<charT>('?'), 
+      static_cast<charT>('>'), 
+      static_cast<charT>('\x0D'), 
+      static_cast<charT>('\x0A'), 
+      static_cast<charT>('?'),
+      static_cast<charT>('|'), 
+      static_cast<charT>('['), 
+      static_cast<charT>('\x0A'), 
+      static_cast<charT>('\x0B'), 
+      static_cast<charT>('\x0C'), 
+      static_cast<charT>('\x85'), 
+      static_cast<charT>(']'), 
+      static_cast<charT>(')'), 
+      static_cast<charT>(')'), 
+      static_cast<charT>('\0') 
+   };
+   return e2;
+#ifdef BOOST_REGEX_MSVC
+#  pragma warning(pop)
+#endif
+}
 
 } // BOOST_REGEX_DETAIL_NS
 } // boost
+
+#endif