passenger 6.0.6 → 6.0.10

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

@@ -195,7 +195,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
       {
       // conditional expression:
       const re_alt* alt = static_cast<const re_alt*>(pstate->next.p);
-      BOOST_ASSERT(alt->type == syntax_element_alt);
+      BOOST_REGEX_ASSERT(alt->type == syntax_element_alt);
       pstate = alt->next.p;
       if(pstate->type == syntax_element_assert_backref)
       {
@@ -206,7 +206,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
       else
       {
          // zero width assertion, have to match this recursively:
-         BOOST_ASSERT(pstate->type == syntax_element_startmark);
+         BOOST_REGEX_ASSERT(pstate->type == syntax_element_startmark);
          bool negated = static_cast<const re_brace*>(pstate)->index == -2;
          BidiIterator saved_position = position;
          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
@@ -235,7 +235,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
       }
    default:
    {
-      BOOST_ASSERT(index > 0);
+      BOOST_REGEX_ASSERT(index > 0);
       if((m_match_flags & match_nosubs) == 0)
       {
          backup_subex<BidiIterator> sub(*m_presult, index);
@@ -548,11 +548,11 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
 #pragma warning(disable:4127)
 #pragma warning(disable:4267)
 #endif
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option push -w-8008 -w-8066 -w-8004
 #endif
    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
-   BOOST_ASSERT(1 == static_cast<const re_literal*>(rep->next.p)->length);
+   BOOST_REGEX_ASSERT(1 == static_cast<const re_literal*>(rep->next.p)->length);
    const char_type what = *reinterpret_cast<const char_type*>(static_cast<const re_literal*>(rep->next.p) + 1);
    //
    // start by working out how much we can skip:
@@ -637,7 +637,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
          return false;
       }
    }while(true);
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option pop
 #endif
 #ifdef BOOST_MSVC
@@ -652,7 +652,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
 #pragma warning(push)
 #pragma warning(disable:4127)
 #endif
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option push -w-8008 -w-8066 -w-8004
 #endif
    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
@@ -732,7 +732,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
          return false;
       }
    }while(true);
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option pop
 #endif
 #ifdef BOOST_MSVC
@@ -747,7 +747,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
 #pragma warning(push)
 #pragma warning(disable:4127)
 #endif
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option push -w-8008 -w-8066 -w-8004
 #endif
    typedef typename traits::char_class_type char_class_type;
@@ -828,7 +828,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
          return false;
       }
    }while(true);
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma option pop
 #endif
 #ifdef BOOST_MSVC
@@ -892,7 +892,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::backtrack_till_match(std::si
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()
 {
-   BOOST_ASSERT(pstate->type == syntax_element_recurse);
+   BOOST_REGEX_ASSERT(pstate->type == syntax_element_recurse);
    //
    // Set new call stack:
    //
@@ -987,7 +987,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
 {
    if(!recursion_stack.empty())
    {
-      BOOST_ASSERT(0 == recursion_stack.back().idx);
+      BOOST_REGEX_ASSERT(0 == recursion_stack.back().idx);
       const re_syntax_base* saved_state = pstate = recursion_stack.back().preturn_address;
       *m_presult = recursion_stack.back().results;
       recursion_stack.pop_back();

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

@@ -46,7 +46,7 @@ template <class S, class charT>
 unsigned count_chars(const S& s, charT c)
 {
    //
-   // Count how many occurances of character c occur
+   // Count how many occurrences of character c occur
    // in string s: if c is a delimeter between collation
    // fields, then this should be the same value for all
    // sort keys:

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

@@ -20,6 +20,8 @@
 #ifndef BOOST_REGEX_V4_PROTECTED_CALL_HPP
 #define BOOST_REGEX_V4_PROTECTED_CALL_HPP
 
+#include <boost/config.hpp>
+
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable: 4103)
@@ -53,7 +55,7 @@ public:
    concrete_protected_call(T* o, proc_type p)
       : obj(o), proc(p) {}
 private:
-   virtual bool call()const;
+   bool call()const BOOST_OVERRIDE;
    T* obj;
    proc_type proc;
 };

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

@@ -87,42 +87,6 @@
 #ifndef BOOST_REGEX_MATCHER_HPP
 #include <boost/regex/v4/perl_matcher.hpp>
 #endif
-//
-// template instances:
-//
-#define BOOST_REGEX_CHAR_T char
-#ifdef BOOST_REGEX_NARROW_INSTANTIATE
-#  define BOOST_REGEX_INSTANTIATE
-#endif
-#include <boost/regex/v4/instances.hpp>
-#undef BOOST_REGEX_CHAR_T
-#ifdef BOOST_REGEX_INSTANTIATE
-#  undef BOOST_REGEX_INSTANTIATE
-#endif
-
-#ifndef BOOST_NO_WREGEX
-#define BOOST_REGEX_CHAR_T wchar_t
-#ifdef BOOST_REGEX_WIDE_INSTANTIATE
-#  define BOOST_REGEX_INSTANTIATE
-#endif
-#include <boost/regex/v4/instances.hpp>
-#undef BOOST_REGEX_CHAR_T
-#ifdef BOOST_REGEX_INSTANTIATE
-#  undef BOOST_REGEX_INSTANTIATE
-#endif
-#endif
-
-#if !defined(BOOST_NO_WREGEX) && defined(BOOST_REGEX_HAS_OTHER_WCHAR_T)
-#define BOOST_REGEX_CHAR_T unsigned short
-#ifdef BOOST_REGEX_US_INSTANTIATE
-#  define BOOST_REGEX_INSTANTIATE
-#endif
-#include <boost/regex/v4/instances.hpp>
-#undef BOOST_REGEX_CHAR_T
-#ifdef BOOST_REGEX_INSTANTIATE
-#  undef BOOST_REGEX_INSTANTIATE
-#endif
-#endif
 
 
 namespace boost{

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

@@ -90,6 +90,10 @@ struct trivial_format_traits
    }
 };
 
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#pragma warning(disable:26812)
+#endif
 template <class OutputIterator, class Results, class traits, class ForwardIter>
 class basic_regex_formatter
 {
@@ -203,6 +207,9 @@ private:
    basic_regex_formatter(const basic_regex_formatter&);
    basic_regex_formatter& operator=(const basic_regex_formatter&);
 };
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
 OutputIterator basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format(ForwardIter p1, ForwardIter p2, match_flag_type f)
@@ -244,7 +251,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
             m_have_conditional = have_conditional;
             if(m_position == m_end)
                return;
-            BOOST_ASSERT(*m_position == static_cast<char_type>(')'));
+            BOOST_REGEX_ASSERT(*m_position == static_cast<char_type>(')'));
             ++m_position;  // skip the closing ')'
             break;
          }
@@ -300,7 +307,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
    // On entry *m_position points to a '$' character
    // output the information that goes with it:
    //
-   BOOST_ASSERT(*m_position == '$');
+   BOOST_REGEX_ASSERT(*m_position == '$');
    //
    // see if this is a trailing '$':
    //
@@ -649,7 +656,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
          len = (std::min)(static_cast<std::ptrdiff_t>(4), len);
          v = this->toi(m_position, m_position + len, 8);
-         BOOST_ASSERT(v >= 0);
+         BOOST_REGEX_ASSERT(v >= 0);
          put(static_cast<char_type>(v));
          break;
       }

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

@@ -50,6 +50,8 @@ class regex_iterator_implementation
 public:
    regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
       : base(), end(last), re(*p), flags(f){}
+   regex_iterator_implementation(const regex_iterator_implementation& other)
+      :what(other.what), base(other.base), end(other.end), re(other.re), flags(other.flags){}
    bool init(BidirectionalIterator first)
    {
       base = first;

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

@@ -106,7 +106,7 @@ enum{
 // this is used by basic_regex for expression storage
 //
 
-class BOOST_REGEX_DECL raw_storage
+class raw_storage
 {
 public:
    typedef std::size_t           size_type;
@@ -123,8 +123,30 @@ public:
       ::operator delete(start);
    }
 
-   void BOOST_REGEX_CALL resize(size_type n);
-   
+   void BOOST_REGEX_CALL resize(size_type n)
+   {
+      size_type newsize = start ? last - start : 1024;
+      while (newsize < n)
+         newsize *= 2;
+      size_type datasize = end - start;
+      // extend newsize to WORD/DWORD boundary:
+      newsize = (newsize + padding_mask) & ~(padding_mask);
+
+      // allocate and copy data:
+      pointer ptr = static_cast<pointer>(::operator new(newsize));
+      BOOST_REGEX_NOEH_ASSERT(ptr)
+         if (start)
+            std::memcpy(ptr, start, datasize);
+
+      // get rid of old buffer:
+      ::operator delete(start);
+
+      // and set up pointers:
+      start = ptr;
+      end = ptr + datasize;
+      last = ptr + newsize;
+   }
+
    void* BOOST_REGEX_CALL extend(size_type n)
    {
       if(size_type(last - end) < n)
@@ -134,7 +156,16 @@ public:
       return result;
    }
 
-   void* BOOST_REGEX_CALL insert(size_type pos, size_type n);
+   void* BOOST_REGEX_CALL insert(size_type pos, size_type n)
+   {
+      BOOST_REGEX_ASSERT(pos <= size_type(end - start));
+      if (size_type(last - end) < n)
+         resize(n + (end - start));
+      void* result = start + pos;
+      std::memmove(start + pos + n, start + pos, (end - start) - pos);
+      end += n;
+      return result;
+   }
 
    size_type BOOST_REGEX_CALL size()
    {

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

@@ -21,7 +21,7 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/detail/workaround.hpp>
-#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
+#if (BOOST_WORKAROUND(BOOST_BORLANDC, >= 0x560) && BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x570)))\
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
 //
 // Borland C++ Builder 6, and Visual C++ 6,
@@ -66,17 +66,19 @@ class regex_token_iterator_implementation
    std::vector<int>                     subs;   // the sub-expressions to enumerate
 
 public:
+   regex_token_iterator_implementation(const regex_token_iterator_implementation& other)
+      : what(other.what), base(other.base), end(other.end), re(other.re), flags(other.flags), result(other.result), N(other.N), subs(other.subs) {}
    regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)
-      : end(last), re(*p), flags(f){ subs.push_back(sub); }
+      : 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), subs(v){}
+      : end(last), re(*p), flags(f), N(0), subs(v){}
 #if !BOOST_WORKAROUND(__HP_aCC, < 60700)
-#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
+#if (BOOST_WORKAROUND(BOOST_BORLANDC, >= 0x560) && BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x570)))\
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
       || BOOST_WORKAROUND(__HP_aCC, < 60700)
    template <class T>
    regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const T& submatches, match_flag_type f)
-      : end(last), re(*p), flags(f)
+      : end(last), re(*p), flags(f), N(0)
    {
       // assert that T really is an array:
       BOOST_STATIC_ASSERT(::boost::is_array<T>::value);
@@ -89,7 +91,7 @@ public:
 #else
    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)
+      : end(last), re(*p), flags(f), N(0)
    {
       for(std::size_t i = 0; i < CN; ++i)
       {
@@ -196,7 +198,7 @@ public:
          pdata.reset();
    }
 #if !BOOST_WORKAROUND(__HP_aCC, < 60700)
-#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
+#if (BOOST_WORKAROUND(BOOST_BORLANDC, >= 0x560) && BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x570)))\
       || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
       || BOOST_WORKAROUND(__HP_aCC, < 60700)
    template <class T>

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

@@ -39,7 +39,7 @@
 #     include <boost/regex/v4/cpp_regex_traits.hpp>
 #  endif
 #endif
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x560)
 #  ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED
 #     include <boost/regex/v4/c_regex_traits.hpp>
 #  endif

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

@@ -31,6 +31,11 @@
 #endif
 
 #include <boost/regex/config.hpp>
+#include <boost/cstdint.hpp>
+
+#include <cctype>
+#include <cwctype>
+#include <locale>
 
 #ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
 #include <boost/regex/v4/syntax_type.hpp>
@@ -38,6 +43,7 @@
 #ifndef BOOST_REGEX_ERROR_TYPE_HPP
 #include <boost/regex/v4/error_type.hpp>
 #endif
+#include <boost/regex/v4/regex_workaround.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 #include <boost/utility/enable_if.hpp>
 
@@ -62,14 +68,548 @@ inline bool is_extended(charT c)
 inline bool is_extended(char)
 { return false; }
 
+inline const char* BOOST_REGEX_CALL 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.
+   const char* messages[] = {
+         "",
+         "(",
+         ")",
+         "$",
+         "^",
+         ".",
+         "*",
+         "+",
+         "?",
+         "[",
+         "]",
+         "|",
+         "\\",
+         "#",
+         "-",
+         "{",
+         "}",
+         "0123456789",
+         "b",
+         "B",
+         "<",
+         ">",
+         "",
+         "",
+         "A`",
+         "z'",
+         "\n",
+         ",",
+         "a",
+         "f",
+         "n",
+         "r",
+         "t",
+         "v",
+         "x",
+         "c",
+         ":",
+         "=",
+         "e",
+         "",
+         "",
+         "",
+         "",
+         "",
+         "",
+         "",
+         "",
+         "E",
+         "Q",
+         "X",
+         "C",
+         "Z",
+         "G",
+         "!",
+         "p",
+         "P",
+         "N",
+         "gk",
+         "K",
+         "R",
+   };
+
+   return ((n >= (sizeof(messages) / sizeof(messages[1]))) ? "" : messages[n]);
+}
+
+inline 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 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];
+}
 
-BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n);
-BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_constants::error_type n);
-BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_syntax_type(char c);
-BOOST_REGEX_DECL regex_constants::escape_syntax_type BOOST_REGEX_CALL get_default_escape_syntax_type(char c);
+inline 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,  /*'*/
+      regex_constants::syntax_open_mark,        /*(*/
+      regex_constants::syntax_close_mark,        /*)*/
+      regex_constants::syntax_star,        /***/
+      regex_constants::syntax_plus,        /*+*/
+      regex_constants::syntax_comma,        /*,*/
+      regex_constants::syntax_dash,        /*-*/
+      regex_constants::syntax_dot,        /*.*/
+      regex_constants::syntax_char,        /*/*/
+      regex_constants::syntax_digit,        /*0*/
+      regex_constants::syntax_digit,        /*1*/
+      regex_constants::syntax_digit,        /*2*/
+      regex_constants::syntax_digit,        /*3*/
+      regex_constants::syntax_digit,        /*4*/
+      regex_constants::syntax_digit,        /*5*/
+      regex_constants::syntax_digit,        /*6*/
+      regex_constants::syntax_digit,        /*7*/
+      regex_constants::syntax_digit,        /*8*/
+      regex_constants::syntax_digit,        /*9*/
+      regex_constants::syntax_colon,        /*:*/
+      regex_constants::syntax_char,        /*;*/
+      regex_constants::escape_type_left_word, /*<*/
+      regex_constants::syntax_equal,        /*=*/
+      regex_constants::escape_type_right_word, /*>*/
+      regex_constants::syntax_question,        /*?*/
+      regex_constants::syntax_char,        /*@*/
+      regex_constants::syntax_char,        /*A*/
+      regex_constants::syntax_char,        /*B*/
+      regex_constants::syntax_char,        /*C*/
+      regex_constants::syntax_char,        /*D*/
+      regex_constants::syntax_char,        /*E*/
+      regex_constants::syntax_char,        /*F*/
+      regex_constants::syntax_char,        /*G*/
+      regex_constants::syntax_char,        /*H*/
+      regex_constants::syntax_char,        /*I*/
+      regex_constants::syntax_char,        /*J*/
+      regex_constants::syntax_char,        /*K*/
+      regex_constants::syntax_char,        /*L*/
+      regex_constants::syntax_char,        /*M*/
+      regex_constants::syntax_char,        /*N*/
+      regex_constants::syntax_char,        /*O*/
+      regex_constants::syntax_char,        /*P*/
+      regex_constants::syntax_char,        /*Q*/
+      regex_constants::syntax_char,        /*R*/
+      regex_constants::syntax_char,        /*S*/
+      regex_constants::syntax_char,        /*T*/
+      regex_constants::syntax_char,        /*U*/
+      regex_constants::syntax_char,        /*V*/
+      regex_constants::syntax_char,        /*W*/
+      regex_constants::syntax_char,        /*X*/
+      regex_constants::syntax_char,        /*Y*/
+      regex_constants::syntax_char,        /*Z*/
+      regex_constants::syntax_open_set,        /*[*/
+      regex_constants::syntax_escape,        /*\*/
+      regex_constants::syntax_close_set,        /*]*/
+      regex_constants::syntax_caret,        /*^*/
+      regex_constants::syntax_char,        /*_*/
+      regex_constants::syntax_char,        /*`*/
+      regex_constants::syntax_char,        /*a*/
+      regex_constants::syntax_char,        /*b*/
+      regex_constants::syntax_char,        /*c*/
+      regex_constants::syntax_char,        /*d*/
+      regex_constants::syntax_char,        /*e*/
+      regex_constants::syntax_char,        /*f*/
+      regex_constants::syntax_char,        /*g*/
+      regex_constants::syntax_char,        /*h*/
+      regex_constants::syntax_char,        /*i*/
+      regex_constants::syntax_char,        /*j*/
+      regex_constants::syntax_char,        /*k*/
+      regex_constants::syntax_char,        /*l*/
+      regex_constants::syntax_char,        /*m*/
+      regex_constants::syntax_char,        /*n*/
+      regex_constants::syntax_char,        /*o*/
+      regex_constants::syntax_char,        /*p*/
+      regex_constants::syntax_char,        /*q*/
+      regex_constants::syntax_char,        /*r*/
+      regex_constants::syntax_char,        /*s*/
+      regex_constants::syntax_char,        /*t*/
+      regex_constants::syntax_char,        /*u*/
+      regex_constants::syntax_char,        /*v*/
+      regex_constants::syntax_char,        /*w*/
+      regex_constants::syntax_char,        /*x*/
+      regex_constants::syntax_char,        /*y*/
+      regex_constants::syntax_char,        /*z*/
+      regex_constants::syntax_open_brace,        /*{*/
+      regex_constants::syntax_or,        /*|*/
+      regex_constants::syntax_close_brace,        /*}*/
+      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,        /**/
+      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,        /**/
+      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,        /**/
+   };
+
+   return char_syntax[(unsigned char)c];
+}
+
+inline regex_constants::escape_syntax_type BOOST_REGEX_CALL 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?
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining_implementation(uint_least16_t s);
+inline 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;
+}
 
 template <class charT>
 inline bool is_combining(charT c)
@@ -138,10 +678,80 @@ inline bool is_separator<char>(char c)
 //
 // get a default collating element:
 //
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);
+inline std::string BOOST_REGEX_CALL 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 clasification, the individual
+// get the state_id of a character classification, the individual
 // traits classes then transform that state_id into a bitmask:
 //
 template <class charT>
@@ -208,8 +818,8 @@ int get_default_class_id(const charT* p1, const charT* p2)
       {data+63, data+67,}, // word
       {data+67, data+73,}, // xdigit
    };
-   static const character_pointer_range<charT>* ranges_begin = ranges;
-   static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
+   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);
@@ -255,15 +865,25 @@ inline charT BOOST_REGEX_CALL global_upper(charT c)
    return c;
 }
 
-BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_lower(char c);
-BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_upper(char c);
+inline char BOOST_REGEX_CALL do_global_lower(char c)
+{
+   return static_cast<char>((std::tolower)((unsigned char)c));
+}
+
+inline 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);
-BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c);
-#endif
-#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_lower(unsigned short c);
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short c);
+inline wchar_t BOOST_REGEX_CALL do_global_lower(wchar_t c)
+{
+   return (std::towlower)(c);
+}
+
+inline wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c)
+{
+   return (std::towupper)(c);
+}
 #endif
 //
 // This sucks: declare template specialisations of global_lower/global_upper
@@ -275,15 +895,11 @@ BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short
 // otherwise the "local template instantiation" compiler option can pick
 // the wrong instantiation when linking:
 //
-template<> inline char BOOST_REGEX_CALL global_lower<char>(char c){ return do_global_lower(c); }
-template<> inline char BOOST_REGEX_CALL global_upper<char>(char c){ return do_global_upper(c); }
+template<> inline char BOOST_REGEX_CALL global_lower<char>(char c) { return do_global_lower(c); }
+template<> inline char BOOST_REGEX_CALL global_upper<char>(char c) { return do_global_upper(c); }
 #ifndef BOOST_NO_WREGEX
-template<> inline wchar_t BOOST_REGEX_CALL global_lower<wchar_t>(wchar_t c){ return do_global_lower(c); }
-template<> inline wchar_t BOOST_REGEX_CALL global_upper<wchar_t>(wchar_t c){ return do_global_upper(c); }
-#endif
-#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-template<> inline unsigned short BOOST_REGEX_CALL global_lower<unsigned short>(unsigned short c){ return do_global_lower(c); }
-template<> inline unsigned short BOOST_REGEX_CALL global_upper<unsigned short>(unsigned short c){ return do_global_upper(c); }
+template<> inline wchar_t BOOST_REGEX_CALL global_lower<wchar_t>(wchar_t c) { return do_global_lower(c); }
+template<> inline wchar_t BOOST_REGEX_CALL global_upper<wchar_t>(wchar_t c) { return do_global_upper(c); }
 #endif
 
 template <class charT>