summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRemko Tronçon <git@el-tramo.be>2009-06-03 21:52:05 (GMT)
committerRemko Tronçon <git@el-tramo.be>2009-06-09 18:18:53 (GMT)
commitfd89da91d12b270d56f60544cad6f1ddc809af28 (patch)
tree77bebb89221cc8023b22efaa0b707cdcd0759b3b /3rdParty/Boost/libs/regex/src
parent3de4268ade36c9292a88b1da7604748a87c65777 (diff)
downloadswift-contrib-fd89da91d12b270d56f60544cad6f1ddc809af28.zip
swift-contrib-fd89da91d12b270d56f60544cad6f1ddc809af28.tar.bz2
Added Boost.regex.
Diffstat (limited to '3rdParty/Boost/libs/regex/src')
-rw-r--r--3rdParty/Boost/libs/regex/src/c_regex_traits.cpp206
-rw-r--r--3rdParty/Boost/libs/regex/src/cpp_regex_traits.cpp117
-rw-r--r--3rdParty/Boost/libs/regex/src/cregex.cpp648
-rw-r--r--3rdParty/Boost/libs/regex/src/fileiter.cpp908
-rw-r--r--3rdParty/Boost/libs/regex/src/icu.cpp495
-rw-r--r--3rdParty/Boost/libs/regex/src/instances.cpp32
-rw-r--r--3rdParty/Boost/libs/regex/src/posix_api.cpp288
-rw-r--r--3rdParty/Boost/libs/regex/src/regex.cpp239
-rw-r--r--3rdParty/Boost/libs/regex/src/regex_debug.cpp59
-rw-r--r--3rdParty/Boost/libs/regex/src/regex_raw_buffer.cpp70
-rw-r--r--3rdParty/Boost/libs/regex/src/regex_traits_defaults.cpp688
-rw-r--r--3rdParty/Boost/libs/regex/src/static_mutex.cpp179
-rw-r--r--3rdParty/Boost/libs/regex/src/usinstances.cpp77
-rw-r--r--3rdParty/Boost/libs/regex/src/w32_regex_traits.cpp650
-rw-r--r--3rdParty/Boost/libs/regex/src/wc_regex_traits.cpp313
-rw-r--r--3rdParty/Boost/libs/regex/src/wide_posix_api.cpp310
-rw-r--r--3rdParty/Boost/libs/regex/src/winstances.cpp35
17 files changed, 5314 insertions, 0 deletions
diff --git a/3rdParty/Boost/libs/regex/src/c_regex_traits.cpp b/3rdParty/Boost/libs/regex/src/c_regex_traits.cpp
new file mode 100644
index 0000000..da960eb
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/c_regex_traits.cpp
@@ -0,0 +1,206 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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: c_regex_traits.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements out of line c_regex_traits<char> members
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
+
+#include <boost/regex/v4/c_regex_traits.hpp>
+#include <boost/regex/v4/primary_transform.hpp>
+#include <boost/regex/v4/regex_traits_defaults.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+ using ::strxfrm; using ::isspace;
+ using ::ispunct; using ::isalpha;
+ using ::isalnum; using ::iscntrl;
+ using ::isprint; using ::isupper;
+ using ::islower; using ::isdigit;
+ using ::isxdigit; using ::strtol;
+}
+#endif
+
+#ifdef BOOST_HAS_ABI_HEADERS
+# include BOOST_ABI_PREFIX
+#endif
+
+namespace boost{
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform(const char* p1, const char* p2)
+{
+ std::string result(10, ' ');
+ std::size_t s = result.size();
+ std::size_t r;
+ std::string src(p1, p2);
+ while(s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))
+ {
+ result.append(r - s + 3, ' ');
+ s = result.size();
+ }
+ result.erase(r);
+ return result;
+}
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform_primary(const char* p1, const char* p2)
+{
+ static char s_delim;
+ static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
+ std::string result;
+ //
+ // What we do here depends upon the format of the sort key returned by
+ // sort key returned by this->transform:
+ //
+ switch(s_collate_type)
+ {
+ case ::boost::re_detail::sort_C:
+ case ::boost::re_detail::sort_unknown:
+ // the best we can do is translate to lower case, then get a regular sort key:
+ {
+ result.assign(p1, p2);
+ for(std::string::size_type i = 0; i < result.size(); ++i)
+ result[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(result[i])));
+ result = transform(&*result.begin(), &*result.begin() + result.size());
+ break;
+ }
+ case ::boost::re_detail::sort_fixed:
+ {
+ // get a regular sort key, and then truncate it:
+ result = transform(p1, p2);
+ result.erase(s_delim);
+ break;
+ }
+ case ::boost::re_detail::sort_delim:
+ // get a regular sort key, and then truncate everything after the delim:
+ result = transform(p1, p2);
+ if(result.size() && (result[0] == s_delim))
+ break;
+ std::size_t i;
+ for(i = 0; i < result.size(); ++i)
+ {
+ if(result[i] == s_delim)
+ break;
+ }
+ result.erase(i);
+ break;
+ }
+ if(result.empty())
+ result = std::string(1, char(0));
+ return result;
+}
+
+enum
+{
+ char_class_space=1<<0,
+ char_class_print=1<<1,
+ char_class_cntrl=1<<2,
+ char_class_upper=1<<3,
+ char_class_lower=1<<4,
+ char_class_alpha=1<<5,
+ char_class_digit=1<<6,
+ char_class_punct=1<<7,
+ char_class_xdigit=1<<8,
+ char_class_alnum=char_class_alpha|char_class_digit,
+ char_class_graph=char_class_alnum|char_class_punct,
+ char_class_blank=1<<9,
+ char_class_word=1<<10,
+ char_class_unicode=1<<11
+};
+
+c_regex_traits<char>::char_class_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_classname(const char* p1, const char* p2)
+{
+ static const char_class_type masks[] =
+ {
+ 0,
+ char_class_alnum,
+ char_class_alpha,
+ char_class_blank,
+ char_class_cntrl,
+ char_class_digit,
+ char_class_digit,
+ char_class_graph,
+ char_class_lower,
+ char_class_lower,
+ char_class_print,
+ char_class_punct,
+ char_class_space,
+ char_class_space,
+ char_class_upper,
+ char_class_unicode,
+ char_class_upper,
+ char_class_alnum | char_class_word,
+ char_class_alnum | char_class_word,
+ char_class_xdigit,
+ };
+
+ int id = ::boost::re_detail::get_default_class_id(p1, p2);
+ if(id < 0)
+ {
+ std::string s(p1, p2);
+ for(std::string::size_type i = 0; i < s.size(); ++i)
+ s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));
+ id = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+ }
+ BOOST_ASSERT(std::size_t(id+1) < sizeof(masks) / sizeof(masks[0]));
+ return masks[id+1];
+}
+
+bool BOOST_REGEX_CALL c_regex_traits<char>::isctype(char c, char_class_type mask)
+{
+ return
+ ((mask & char_class_space) && (std::isspace)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_print) && (std::isprint)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_cntrl) && (std::iscntrl)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_upper) && (std::isupper)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_lower) && (std::islower)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_alpha) && (std::isalpha)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))
+ || ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::re_detail::is_separator(c))
+ || ((mask & char_class_word) && (c == '_'));
+}
+
+c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)
+{
+ std::string s(p1, p2);
+ s = ::boost::re_detail::lookup_default_collate_name(s);
+ if(s.empty() && (p2-p1 == 1))
+ s.append(1, *p1);
+ return s;
+}
+
+int BOOST_REGEX_CALL c_regex_traits<char>::value(char c, int radix)
+{
+ char b[2] = { c, '\0', };
+ char* ep;
+ int result = std::strtol(b, &ep, radix);
+ if(ep == b)
+ return -1;
+ return result;
+}
+
+}
+#ifdef BOOST_HAS_ABI_HEADERS
+# include BOOST_ABI_SUFFIX
+#endif
+
+#endif
diff --git a/3rdParty/Boost/libs/regex/src/cpp_regex_traits.cpp b/3rdParty/Boost/libs/regex/src/cpp_regex_traits.cpp
new file mode 100644
index 0000000..9ed66be
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/cpp_regex_traits.cpp
@@ -0,0 +1,117 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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 cpp_regex_traits.cpp
+ * VERSION see <boost/version.hpp>
+ * DESCRIPTION: Implements cpp_regex_traits<char> (and associated helper classes).
+ */
+
+#define BOOST_REGEX_SOURCE
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_LOCALE
+#include <boost/regex/regex_traits.hpp>
+#include <boost/regex/pattern_except.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+ using ::memset;
+}
+#endif
+
+namespace boost{ namespace re_detail{
+
+void cpp_regex_traits_char_layer<char>::init()
+{
+ // we need to start by initialising our syntax map so we know which
+ // character is used for which purpose:
+ std::memset(m_char_map, 0, sizeof(m_char_map));
+#ifndef BOOST_NO_STD_MESSAGES
+#ifndef __IBMCPP__
+ std::messages<char>::catalog cat = static_cast<std::messages<char>::catalog>(-1);
+#else
+ std::messages<char>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1);
+#endif
+ std::string cat_name(cpp_regex_traits<char>::get_catalog_name());
+ if(cat_name.size())
+ {
+ cat = this->m_pmessages->open(
+ cat_name,
+ this->m_locale);
+ if((int)cat < 0)
+ {
+ std::string m("Unable to open message catalog: ");
+ std::runtime_error err(m + cat_name);
+ boost::re_detail::raise_runtime_error(err);
+ }
+ }
+ //
+ // if we have a valid catalog then load our messages:
+ //
+ if((int)cat >= 0)
+ {
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
+ {
+ string_type mss = this->m_pmessages->get(cat, 0, i, get_default_syntax(i));
+ for(string_type::size_type j = 0; j < mss.size(); ++j)
+ {
+ m_char_map[static_cast<unsigned char>(mss[j])] = i;
+ }
+ }
+ this->m_pmessages->close(cat);
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ this->m_pmessages->close(cat);
+ throw;
+ }
+#endif
+ }
+ else
+ {
+#endif
+ for(regex_constants::syntax_type j = 1; j < regex_constants::syntax_max; ++j)
+ {
+ const char* ptr = get_default_syntax(j);
+ while(ptr && *ptr)
+ {
+ m_char_map[static_cast<unsigned char>(*ptr)] = j;
+ ++ptr;
+ }
+ }
+#ifndef BOOST_NO_STD_MESSAGES
+ }
+#endif
+ //
+ // finish off by calculating our escape types:
+ //
+ unsigned char i = 'A';
+ do
+ {
+ if(m_char_map[i] == 0)
+ {
+ if(this->m_pctype->is(std::ctype_base::lower, i))
+ m_char_map[i] = regex_constants::escape_type_class;
+ else if(this->m_pctype->is(std::ctype_base::upper, i))
+ m_char_map[i] = regex_constants::escape_type_not_class;
+ }
+ }while(0xFF != i++);
+}
+
+} // re_detail
+} // boost
+#endif
+
diff --git a/3rdParty/Boost/libs/regex/src/cregex.cpp b/3rdParty/Boost/libs/regex/src/cregex.cpp
new file mode 100644
index 0000000..fb12373
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/cregex.cpp
@@ -0,0 +1,648 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: cregex.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements high level class boost::RexEx
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex.hpp>
+#include <boost/cregex.hpp>
+#if !defined(BOOST_NO_STD_STRING)
+#include <map>
+#include <list>
+#include <boost/regex/v4/fileiter.hpp>
+typedef boost::match_flag_type match_flag_type;
+#include <cstdio>
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4309)
+#endif
+
+namespace boost{
+
+#ifdef __BORLANDC__
+#if __BORLANDC__ < 0x530
+//
+// we need to instantiate the vector classes we use
+// since declaring a reference to type doesn't seem to
+// do the job...
+std::vector<std::size_t> inst1;
+std::vector<std::string> inst2;
+#endif
+#endif
+
+namespace{
+
+template <class iterator>
+std::string to_string(iterator i, iterator j)
+{
+ std::string s;
+ while(i != j)
+ {
+ s.append(1, *i);
+ ++i;
+ }
+ return s;
+}
+
+inline std::string to_string(const char* i, const char* j)
+{
+ return std::string(i, j);
+}
+
+}
+namespace re_detail{
+
+class RegExData
+{
+public:
+ enum type
+ {
+ type_pc,
+ type_pf,
+ type_copy
+ };
+ regex e;
+ cmatch m;
+#ifndef BOOST_REGEX_NO_FILEITER
+ match_results<mapfile::iterator> fm;
+#endif
+ type t;
+ const char* pbase;
+#ifndef BOOST_REGEX_NO_FILEITER
+ mapfile::iterator fbase;
+#endif
+ std::map<int, std::string, std::less<int> > strings;
+ std::map<int, std::ptrdiff_t, std::less<int> > positions;
+ void update();
+ void clean();
+ RegExData() : e(), m(),
+#ifndef BOOST_REGEX_NO_FILEITER
+ fm(),
+#endif
+ t(type_copy), pbase(0),
+#ifndef BOOST_REGEX_NO_FILEITER
+ fbase(),
+#endif
+ strings(), positions() {}
+};
+
+void RegExData::update()
+{
+ strings.erase(strings.begin(), strings.end());
+ positions.erase(positions.begin(), positions.end());
+ if(t == type_pc)
+ {
+ for(unsigned int i = 0; i < m.size(); ++i)
+ {
+ if(m[i].matched) strings[i] = std::string(m[i].first, m[i].second);
+ positions[i] = m[i].matched ? m[i].first - pbase : -1;
+ }
+ }
+#ifndef BOOST_REGEX_NO_FILEITER
+ else
+ {
+ for(unsigned int i = 0; i < fm.size(); ++i)
+ {
+ if(fm[i].matched) strings[i] = to_string(fm[i].first, fm[i].second);
+ positions[i] = fm[i].matched ? fm[i].first - fbase : -1;
+ }
+ }
+#endif
+ t = type_copy;
+}
+
+void RegExData::clean()
+{
+#ifndef BOOST_REGEX_NO_FILEITER
+ fbase = mapfile::iterator();
+ fm = match_results<mapfile::iterator>();
+#endif
+}
+
+} // namespace
+
+RegEx::RegEx()
+{
+ pdata = new re_detail::RegExData();
+}
+
+RegEx::RegEx(const RegEx& o)
+{
+ pdata = new re_detail::RegExData(*(o.pdata));
+}
+
+RegEx::~RegEx()
+{
+ delete pdata;
+}
+
+RegEx::RegEx(const char* c, bool icase)
+{
+ pdata = new re_detail::RegExData();
+ SetExpression(c, icase);
+}
+
+RegEx::RegEx(const std::string& s, bool icase)
+{
+ pdata = new re_detail::RegExData();
+ SetExpression(s.c_str(), icase);
+}
+
+RegEx& RegEx::operator=(const RegEx& o)
+{
+ *pdata = *(o.pdata);
+ return *this;
+}
+
+RegEx& RegEx::operator=(const char* p)
+{
+ SetExpression(p, false);
+ return *this;
+}
+
+unsigned int RegEx::SetExpression(const char* p, bool icase)
+{
+ boost::uint_fast32_t f = icase ? regex::normal | regex::icase : regex::normal;
+ return pdata->e.set_expression(p, f);
+}
+
+unsigned int RegEx::error_code()const
+{
+ return pdata->e.error_code();
+}
+
+
+std::string RegEx::Expression()const
+{
+ return pdata->e.expression();
+}
+
+//
+// now matching operators:
+//
+bool RegEx::Match(const char* p, match_flag_type flags)
+{
+ pdata->t = re_detail::RegExData::type_pc;
+ pdata->pbase = p;
+ const char* end = p;
+ while(*end)++end;
+
+ if(regex_match(p, end, pdata->m, pdata->e, flags))
+ {
+ pdata->update();
+ return true;
+ }
+ return false;
+}
+
+bool RegEx::Search(const char* p, match_flag_type flags)
+{
+ pdata->t = re_detail::RegExData::type_pc;
+ pdata->pbase = p;
+ const char* end = p;
+ while(*end)++end;
+
+ if(regex_search(p, end, pdata->m, pdata->e, flags))
+ {
+ pdata->update();
+ return true;
+ }
+ return false;
+}
+namespace re_detail{
+struct pred1
+{
+ GrepCallback cb;
+ RegEx* pe;
+ pred1(GrepCallback c, RegEx* i) : cb(c), pe(i) {}
+ bool operator()(const cmatch& m)
+ {
+ pe->pdata->m = m;
+ return cb(*pe);
+ }
+};
+}
+unsigned int RegEx::Grep(GrepCallback cb, const char* p, match_flag_type flags)
+{
+ pdata->t = re_detail::RegExData::type_pc;
+ pdata->pbase = p;
+ const char* end = p;
+ while(*end)++end;
+
+ unsigned int result = regex_grep(re_detail::pred1(cb, this), p, end, pdata->e, flags);
+ if(result)
+ pdata->update();
+ return result;
+}
+namespace re_detail{
+struct pred2
+{
+ std::vector<std::string>& v;
+ RegEx* pe;
+ pred2(std::vector<std::string>& o, RegEx* e) : v(o), pe(e) {}
+ bool operator()(const cmatch& m)
+ {
+ pe->pdata->m = m;
+ v.push_back(std::string(m[0].first, m[0].second));
+ return true;
+ }
+private:
+ pred2& operator=(const pred2&);
+};
+}
+
+unsigned int RegEx::Grep(std::vector<std::string>& v, const char* p, match_flag_type flags)
+{
+ pdata->t = re_detail::RegExData::type_pc;
+ pdata->pbase = p;
+ const char* end = p;
+ while(*end)++end;
+
+ unsigned int result = regex_grep(re_detail::pred2(v, this), p, end, pdata->e, flags);
+ if(result)
+ pdata->update();
+ return result;
+}
+namespace re_detail{
+struct pred3
+{
+ std::vector<std::size_t>& v;
+ const char* base;
+ RegEx* pe;
+ pred3(std::vector<std::size_t>& o, const char* pb, RegEx* p) : v(o), base(pb), pe(p) {}
+ bool operator()(const cmatch& m)
+ {
+ pe->pdata->m = m;
+ v.push_back(static_cast<std::size_t>(m[0].first - base));
+ return true;
+ }
+private:
+ pred3& operator=(const pred3&);
+};
+}
+unsigned int RegEx::Grep(std::vector<std::size_t>& v, const char* p, match_flag_type flags)
+{
+ pdata->t = re_detail::RegExData::type_pc;
+ pdata->pbase = p;
+ const char* end = p;
+ while(*end)++end;
+
+ unsigned int result = regex_grep(re_detail::pred3(v, p, this), p, end, pdata->e, flags);
+ if(result)
+ pdata->update();
+ return result;
+}
+#ifndef BOOST_REGEX_NO_FILEITER
+namespace re_detail{
+struct pred4
+{
+ GrepFileCallback cb;
+ RegEx* pe;
+ const char* file;
+ bool ok;
+ pred4(GrepFileCallback c, RegEx* i, const char* f) : cb(c), pe(i), file(f), ok(true) {}
+ bool operator()(const match_results<mapfile::iterator>& m)
+ {
+ pe->pdata->t = RegExData::type_pf;
+ pe->pdata->fm = m;
+ pe->pdata->update();
+ ok = cb(file, *pe);
+ return ok;
+ }
+};
+}
+namespace{
+void BuildFileList(std::list<std::string>* pl, const char* files, bool recurse)
+{
+ file_iterator start(files);
+ file_iterator end;
+ if(recurse)
+ {
+ // go through sub directories:
+ char buf[MAX_PATH];
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(buf, MAX_PATH, start.root()));
+ if(*buf == 0)
+ {
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(buf, MAX_PATH, "."));
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, "*"));
+ }
+ else
+ {
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, "*"));
+ }
+ directory_iterator dstart(buf);
+ directory_iterator dend;
+
+ // now get the file mask bit of "files":
+ const char* ptr = files;
+ while(*ptr) ++ptr;
+ while((ptr != files) && (*ptr != *directory_iterator::separator()) && (*ptr != '/'))--ptr;
+ if(ptr != files) ++ptr;
+
+ while(dstart != dend)
+ {
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ (::sprintf_s)(buf, sizeof(buf), "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
+#else
+ (std::sprintf)(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
+#endif
+ BuildFileList(pl, buf, recurse);
+ ++dstart;
+ }
+ }
+ while(start != end)
+ {
+ pl->push_back(*start);
+ ++start;
+ }
+}
+}
+
+unsigned int RegEx::GrepFiles(GrepFileCallback cb, const char* files, bool recurse, match_flag_type flags)
+{
+ unsigned int result = 0;
+ std::list<std::string> file_list;
+ BuildFileList(&file_list, files, recurse);
+ std::list<std::string>::iterator start, end;
+ start = file_list.begin();
+ end = file_list.end();
+
+ while(start != end)
+ {
+ mapfile map((*start).c_str());
+ pdata->t = re_detail::RegExData::type_pf;
+ pdata->fbase = map.begin();
+ re_detail::pred4 pred(cb, this, (*start).c_str());
+ int r = regex_grep(pred, map.begin(), map.end(), pdata->e, flags);
+ result += r;
+ ++start;
+ pdata->clean();
+ if(pred.ok == false)
+ return result;
+ }
+
+ return result;
+}
+
+
+unsigned int RegEx::FindFiles(FindFilesCallback cb, const char* files, bool recurse, match_flag_type flags)
+{
+ unsigned int result = 0;
+ std::list<std::string> file_list;
+ BuildFileList(&file_list, files, recurse);
+ std::list<std::string>::iterator start, end;
+ start = file_list.begin();
+ end = file_list.end();
+
+ while(start != end)
+ {
+ mapfile map((*start).c_str());
+ pdata->t = re_detail::RegExData::type_pf;
+ pdata->fbase = map.begin();
+
+ if(regex_search(map.begin(), map.end(), pdata->fm, pdata->e, flags))
+ {
+ ++result;
+ if(false == cb((*start).c_str()))
+ return result;
+ }
+ //pdata->update();
+ ++start;
+ //pdata->clean();
+ }
+
+ return result;
+}
+#endif
+
+#ifdef BOOST_REGEX_V3
+#define regex_replace regex_merge
+#endif
+
+std::string RegEx::Merge(const std::string& in, const std::string& fmt,
+ bool copy, match_flag_type flags)
+{
+ std::string result;
+ re_detail::string_out_iterator<std::string> i(result);
+ if(!copy) flags |= format_no_copy;
+ regex_replace(i, in.begin(), in.end(), pdata->e, fmt.c_str(), flags);
+ return result;
+}
+
+std::string RegEx::Merge(const char* in, const char* fmt,
+ bool copy, match_flag_type flags)
+{
+ std::string result;
+ if(!copy) flags |= format_no_copy;
+ re_detail::string_out_iterator<std::string> i(result);
+ regex_replace(i, in, in + std::strlen(in), pdata->e, fmt, flags);
+ return result;
+}
+
+std::size_t RegEx::Split(std::vector<std::string>& v,
+ std::string& s,
+ match_flag_type flags,
+ unsigned max_count)
+{
+ return regex_split(std::back_inserter(v), s, pdata->e, flags, max_count);
+}
+
+
+
+//
+// now operators for returning what matched in more detail:
+//
+std::size_t RegEx::Position(int i)const
+{
+ switch(pdata->t)
+ {
+ case re_detail::RegExData::type_pc:
+ return pdata->m[i].matched ? pdata->m[i].first - pdata->pbase : RegEx::npos;
+#ifndef BOOST_REGEX_NO_FILEITER
+ case re_detail::RegExData::type_pf:
+ return pdata->fm[i].matched ? pdata->fm[i].first - pdata->fbase : RegEx::npos;
+#endif
+ case re_detail::RegExData::type_copy:
+ {
+ std::map<int, std::ptrdiff_t, std::less<int> >::iterator pos = pdata->positions.find(i);
+ if(pos == pdata->positions.end())
+ return RegEx::npos;
+ return (*pos).second;
+ }
+ }
+ return RegEx::npos;
+}
+
+std::size_t RegEx::Marks()const
+{
+ return pdata->e.mark_count();
+}
+
+
+std::size_t RegEx::Length(int i)const
+{
+ switch(pdata->t)
+ {
+ case re_detail::RegExData::type_pc:
+ return pdata->m[i].matched ? pdata->m[i].second - pdata->m[i].first : RegEx::npos;
+#ifndef BOOST_REGEX_NO_FILEITER
+ case re_detail::RegExData::type_pf:
+ return pdata->fm[i].matched ? pdata->fm[i].second - pdata->fm[i].first : RegEx::npos;
+#endif
+ case re_detail::RegExData::type_copy:
+ {
+ std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
+ if(pos == pdata->strings.end())
+ return RegEx::npos;
+ return (*pos).second.size();
+ }
+ }
+ return RegEx::npos;
+}
+
+bool RegEx::Matched(int i)const
+{
+ switch(pdata->t)
+ {
+ case re_detail::RegExData::type_pc:
+ return pdata->m[i].matched;
+#ifndef BOOST_REGEX_NO_FILEITER
+ case re_detail::RegExData::type_pf:
+ return pdata->fm[i].matched;
+#endif
+ case re_detail::RegExData::type_copy:
+ {
+ std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
+ if(pos == pdata->strings.end())
+ return false;
+ return true;
+ }
+ }
+ return false;
+}
+
+
+std::string RegEx::What(int i)const
+{
+ std::string result;
+ switch(pdata->t)
+ {
+ case re_detail::RegExData::type_pc:
+ if(pdata->m[i].matched)
+ result.assign(pdata->m[i].first, pdata->m[i].second);
+ break;
+ case re_detail::RegExData::type_pf:
+ if(pdata->m[i].matched)
+ result.assign(to_string(pdata->m[i].first, pdata->m[i].second));
+ break;
+ case re_detail::RegExData::type_copy:
+ {
+ std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
+ if(pos != pdata->strings.end())
+ result = (*pos).second;
+ break;
+ }
+ }
+ return result;
+}
+
+#ifdef BOOST_HAS_LONG_LONG
+const std::size_t RegEx::npos = static_cast<std::size_t>(~0ULL);
+#else
+const std::size_t RegEx::npos = static_cast<std::size_t>(~0UL);
+#endif
+
+} // namespace boost
+
+#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x550) && (__BORLANDC__ <= 0x551) && !defined(_RWSTD_COMPILE_INSTANTIATE)
+//
+// this is an ugly hack to work around an ugly problem:
+// by default this file will produce unresolved externals during
+// linking unless _RWSTD_COMPILE_INSTANTIATE is defined (Borland bug).
+// However if _RWSTD_COMPILE_INSTANTIATE is defined then we get separate
+// copies of basic_string's static data in the RTL and this DLL, this messes
+// with basic_string's memory management and results in run-time crashes,
+// Oh sweet joy of Catch 22....
+//
+namespace std{
+template<> template<>
+basic_string<char>& BOOST_REGEX_DECL
+basic_string<char>::replace<const char*>(char* f1, char* f2, const char* i1, const char* i2)
+{
+ unsigned insert_pos = f1 - begin();
+ unsigned remove_len = f2 - f1;
+ unsigned insert_len = i2 - i1;
+ unsigned org_size = size();
+ if(insert_len > remove_len)
+ {
+ append(insert_len-remove_len, ' ');
+ std::copy_backward(begin() + insert_pos + remove_len, begin() + org_size, end());
+ std::copy(i1, i2, begin() + insert_pos);
+ }
+ else
+ {
+ std::copy(begin() + insert_pos + remove_len, begin() + org_size, begin() + insert_pos + insert_len);
+ std::copy(i1, i2, begin() + insert_pos);
+ erase(size() + insert_len - remove_len);
+ }
+ return *this;
+}
+template<> template<>
+basic_string<wchar_t>& BOOST_REGEX_DECL
+basic_string<wchar_t>::replace<const wchar_t*>(wchar_t* f1, wchar_t* f2, const wchar_t* i1, const wchar_t* i2)
+{
+ unsigned insert_pos = f1 - begin();
+ unsigned remove_len = f2 - f1;
+ unsigned insert_len = i2 - i1;
+ unsigned org_size = size();
+ if(insert_len > remove_len)
+ {
+ append(insert_len-remove_len, ' ');
+ std::copy_backward(begin() + insert_pos + remove_len, begin() + org_size, end());
+ std::copy(i1, i2, begin() + insert_pos);
+ }
+ else
+ {
+ std::copy(begin() + insert_pos + remove_len, begin() + org_size, begin() + insert_pos + insert_len);
+ std::copy(i1, i2, begin() + insert_pos);
+ erase(size() + insert_len - remove_len);
+ }
+ return *this;
+}
+} // namespace std
+#endif
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/fileiter.cpp b/3rdParty/Boost/libs/regex/src/fileiter.cpp
new file mode 100644
index 0000000..7d9c7f8
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/fileiter.cpp
@@ -0,0 +1,908 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: fileiter.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements file io primitives + directory searching for class boost::RegEx.
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <climits>
+#include <stdexcept>
+#include <string>
+#include <boost/throw_exception.hpp>
+#include <boost/regex/v4/fileiter.hpp>
+#include <boost/regex/v4/regex_workaround.hpp>
+#include <boost/regex/pattern_except.hpp>
+
+#include <cstdio>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::sprintf;
+ using ::fseek;
+ using ::fread;
+ using ::ftell;
+ using ::fopen;
+ using ::fclose;
+ using ::FILE;
+ using ::strcpy;
+ using ::strcpy;
+ using ::strcat;
+ using ::strcmp;
+ using ::strlen;
+}
+#endif
+
+
+#ifndef BOOST_REGEX_NO_FILEITER
+
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+#include <sys/cygwin.h>
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning(disable: 4800)
+#endif
+
+namespace boost{
+ namespace re_detail{
+// start with the operating system specific stuff:
+
+#if (defined(__BORLANDC__) || defined(BOOST_REGEX_FI_WIN32_DIR) || defined(BOOST_MSVC)) && !defined(BOOST_RE_NO_WIN32)
+
+// platform is DOS or Windows
+// directories are separated with '\\'
+// and names are insensitive of case
+
+BOOST_REGEX_DECL const char* _fi_sep = "\\";
+const char* _fi_sep_alt = "/";
+#define BOOST_REGEX_FI_TRANSLATE(c) std::tolower(c)
+
+#else
+
+// platform is not DOS or Windows
+// directories are separated with '/'
+// and names are sensitive of case
+
+BOOST_REGEX_DECL const char* _fi_sep = "/";
+const char* _fi_sep_alt = _fi_sep;
+#define BOOST_REGEX_FI_TRANSLATE(c) c
+
+#endif
+
+#ifdef BOOST_REGEX_FI_WIN32_MAP
+
+void mapfile::open(const char* file)
+{
+#if defined(BOOST_NO_ANSI_APIS)
+ int filename_size = strlen(file);
+ LPWSTR wide_file = (LPWSTR)_alloca( (filename_size + 1) * sizeof(WCHAR) );
+ if(::MultiByteToWideChar(CP_ACP, 0, file, filename_size, wide_file, filename_size + 1) == 0)
+ hfile = INVALID_HANDLE_VALUE;
+ else
+ hfile = CreateFileW(wide_file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+#elif defined(__CYGWIN__)||defined(__CYGWIN32__)
+ char win32file[ MAX_PATH ];
+ cygwin_conv_to_win32_path( file, win32file );
+ hfile = CreateFileA(win32file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+#else
+ hfile = CreateFileA(file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+#endif
+ if(hfile != INVALID_HANDLE_VALUE)
+ {
+ hmap = CreateFileMapping(hfile, 0, PAGE_READONLY, 0, 0, 0);
+ if((hmap == INVALID_HANDLE_VALUE) || (hmap == NULL))
+ {
+ CloseHandle(hfile);
+ hmap = 0;
+ hfile = 0;
+ std::runtime_error err("Unable to create file mapping.");
+ boost::re_detail::raise_runtime_error(err);
+ }
+ _first = static_cast<const char*>(MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0));
+ if(_first == 0)
+ {
+ CloseHandle(hmap);
+ CloseHandle(hfile);
+ hmap = 0;
+ hfile = 0;
+ std::runtime_error err("Unable to create file mapping.");
+ }
+ _last = _first + GetFileSize(hfile, 0);
+ }
+ else
+ {
+ hfile = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ throw std::runtime_error("Unable to open file.");
+#else
+ BOOST_REGEX_NOEH_ASSERT(hfile != INVALID_HANDLE_VALUE);
+#endif
+ }
+}
+
+void mapfile::close()
+{
+ if(hfile != INVALID_HANDLE_VALUE)
+ {
+ UnmapViewOfFile((void*)_first);
+ CloseHandle(hmap);
+ CloseHandle(hfile);
+ hmap = hfile = 0;
+ _first = _last = 0;
+ }
+}
+
+#elif !defined(BOOST_RE_NO_STL)
+
+mapfile_iterator& mapfile_iterator::operator = (const mapfile_iterator& i)
+{
+ if(file && node)
+ file->unlock(node);
+ file = i.file;
+ node = i.node;
+ offset = i.offset;
+ if(file)
+ file->lock(node);
+ return *this;
+}
+
+mapfile_iterator& mapfile_iterator::operator++ ()
+{
+ if((++offset == mapfile::buf_size) && file)
+ {
+ ++node;
+ offset = 0;
+ file->lock(node);
+ file->unlock(node-1);
+ }
+ return *this;
+}
+
+mapfile_iterator mapfile_iterator::operator++ (int)
+{
+ mapfile_iterator temp(*this);
+ if((++offset == mapfile::buf_size) && file)
+ {
+ ++node;
+ offset = 0;
+ file->lock(node);
+ file->unlock(node-1);
+ }
+ return temp;
+}
+
+mapfile_iterator& mapfile_iterator::operator-- ()
+{
+ if((offset == 0) && file)
+ {
+ --node;
+ offset = mapfile::buf_size - 1;
+ file->lock(node);
+ file->unlock(node + 1);
+ }
+ else
+ --offset;
+ return *this;
+}
+
+mapfile_iterator mapfile_iterator::operator-- (int)
+{
+ mapfile_iterator temp(*this);
+ if((offset == 0) && file)
+ {
+ --node;
+ offset = mapfile::buf_size - 1;
+ file->lock(node);
+ file->unlock(node + 1);
+ }
+ else
+ --offset;
+ return temp;
+}
+
+mapfile_iterator operator + (const mapfile_iterator& i, long off)
+{
+ mapfile_iterator temp(i);
+ temp += off;
+ return temp;
+}
+
+mapfile_iterator operator - (const mapfile_iterator& i, long off)
+{
+ mapfile_iterator temp(i);
+ temp -= off;
+ return temp;
+}
+
+mapfile::iterator mapfile::begin()const
+{
+ return mapfile_iterator(this, 0);
+}
+
+mapfile::iterator mapfile::end()const
+{
+ return mapfile_iterator(this, _size);
+}
+
+void mapfile::lock(pointer* node)const
+{
+ BOOST_ASSERT(node >= _first);
+ BOOST_ASSERT(node <= _last);
+ if(node < _last)
+ {
+ if(*node == 0)
+ {
+ if(condemed.empty())
+ {
+ *node = new char[sizeof(int) + buf_size];
+ *(reinterpret_cast<int*>(*node)) = 1;
+ }
+ else
+ {
+ pointer* p = condemed.front();
+ condemed.pop_front();
+ *node = *p;
+ *p = 0;
+ *(reinterpret_cast<int*>(*node)) = 1;
+ }
+ std::fseek(hfile, (node - _first) * buf_size, SEEK_SET);
+ if(node == _last - 1)
+ std::fread(*node + sizeof(int), _size % buf_size, 1, hfile);
+ else
+ std::fread(*node + sizeof(int), buf_size, 1, hfile);
+ }
+ else
+ {
+ if(*reinterpret_cast<int*>(*node) == 0)
+ {
+ *reinterpret_cast<int*>(*node) = 1;
+ condemed.remove(node);
+ }
+ else
+ ++(*reinterpret_cast<int*>(*node));
+ }
+ }
+}
+
+void mapfile::unlock(pointer* node)const
+{
+ BOOST_ASSERT(node >= _first);
+ BOOST_ASSERT(node <= _last);
+ if(node < _last)
+ {
+ if(--(*reinterpret_cast<int*>(*node)) == 0)
+ {
+ condemed.push_back(node);
+ }
+ }
+}
+
+long int get_file_length(std::FILE* hfile)
+{
+ long int result;
+ std::fseek(hfile, 0, SEEK_END);
+ result = std::ftell(hfile);
+ std::fseek(hfile, 0, SEEK_SET);
+ return result;
+}
+
+
+void mapfile::open(const char* file)
+{
+ hfile = std::fopen(file, "rb");
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ if(hfile != 0)
+ {
+ _size = get_file_length(hfile);
+ long cnodes = (_size + buf_size - 1) / buf_size;
+
+ // check that number of nodes is not too high:
+ if(cnodes > (long)((INT_MAX) / sizeof(pointer*)))
+ {
+ std::fclose(hfile);
+ hfile = 0;
+ _size = 0;
+ return;
+ }
+
+ _first = new pointer[(int)cnodes];
+ _last = _first + cnodes;
+ std::memset(_first, 0, cnodes*sizeof(pointer));
+ }
+ else
+ {
+ std::runtime_error err("Unable to open file.");
+ }
+#ifndef BOOST_NO_EXCEPTIONS
+ }catch(...)
+ { close(); throw; }
+#endif
+}
+
+void mapfile::close()
+{
+ if(hfile != 0)
+ {
+ pointer* p = _first;
+ while(p != _last)
+ {
+ if(*p)
+ delete[] *p;
+ ++p;
+ }
+ delete[] _first;
+ _size = 0;
+ _first = _last = 0;
+ std::fclose(hfile);
+ hfile = 0;
+ condemed.erase(condemed.begin(), condemed.end());
+ }
+}
+
+
+#endif
+
+inline _fi_find_handle find_first_file(const char* wild, _fi_find_data& data)
+{
+#ifdef BOOST_NO_ANSI_APIS
+ std::size_t wild_size = std::strlen(wild);
+ LPWSTR wide_wild = (LPWSTR)_alloca( (wild_size + 1) * sizeof(WCHAR) );
+ if (::MultiByteToWideChar(CP_ACP, 0, wild, wild_size, wide_wild, wild_size + 1) == 0)
+ return _fi_invalid_handle;
+
+ return FindFirstFileW(wide_wild, &data);
+#else
+ return FindFirstFileA(wild, &data);
+#endif
+}
+
+inline bool find_next_file(_fi_find_handle hf, _fi_find_data& data)
+{
+#ifdef BOOST_NO_ANSI_APIS
+ return FindNextFileW(hf, &data);
+#else
+ return FindNextFileA(hf, &data);
+#endif
+}
+
+inline void copy_find_file_result_with_overflow_check(const _fi_find_data& data, char* path, size_t max_size)
+{
+#ifdef BOOST_NO_ANSI_APIS
+ if (::WideCharToMultiByte(CP_ACP, 0, data.cFileName, -1, path, max_size, NULL, NULL) == 0)
+ re_detail::overflow_error_if_not_zero(1);
+#else
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(path, max_size, data.cFileName));
+#endif
+}
+
+inline bool is_not_current_or_parent_path_string(const _fi_find_data& data)
+{
+#ifdef BOOST_NO_ANSI_APIS
+ return (std::wcscmp(data.cFileName, L".") && std::wcscmp(data.cFileName, L".."));
+#else
+ return (std::strcmp(data.cFileName, ".") && std::strcmp(data.cFileName, ".."));
+#endif
+}
+
+
+file_iterator::file_iterator()
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ ptr = _path;
+ *_path = 0;
+ *_root = 0;
+ ref = new file_iterator_ref();
+ BOOST_REGEX_NOEH_ASSERT(ref)
+ ref->hf = _fi_invalid_handle;
+ ref->count = 1;
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ delete ref;
+ throw;
+ }
+#endif
+}
+
+file_iterator::file_iterator(const char* wild)
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, wild));
+ ptr = _root;
+ while(*ptr)++ptr;
+ while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
+ if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
+ {
+ _root[1]='\0';
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
+ }
+ else
+ {
+ *ptr = 0;
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
+ if(*_path == 0)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, "."));
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(_path, MAX_PATH, _fi_sep));
+ }
+ ptr = _path + std::strlen(_path);
+
+ ref = new file_iterator_ref();
+ BOOST_REGEX_NOEH_ASSERT(ref)
+ ref->hf = find_first_file(wild, ref->_data);
+ ref->count = 1;
+
+ if(ref->hf == _fi_invalid_handle)
+ {
+ *_path = 0;
+ ptr = _path;
+ }
+ else
+ {
+ copy_find_file_result_with_overflow_check(ref->_data, ptr, (MAX_PATH - (ptr - _path)));
+ if(ref->_data.dwFileAttributes & _fi_dir)
+ next();
+ }
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ delete ref;
+ throw;
+ }
+#endif
+}
+
+file_iterator::file_iterator(const file_iterator& other)
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
+ ptr = _path + (other.ptr - other._path);
+ ref = other.ref;
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ throw;
+ }
+#endif
+ ++(ref->count);
+}
+
+file_iterator& file_iterator::operator=(const file_iterator& other)
+{
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
+ ptr = _path + (other.ptr - other._path);
+ if(--(ref->count) == 0)
+ {
+ if(ref->hf != _fi_invalid_handle)
+ FindClose(ref->hf);
+ delete ref;
+ }
+ ref = other.ref;
+ ++(ref->count);
+ return *this;
+}
+
+
+file_iterator::~file_iterator()
+{
+ delete[] _root;
+ delete[] _path;
+ if(--(ref->count) == 0)
+ {
+ if(ref->hf != _fi_invalid_handle)
+ FindClose(ref->hf);
+ delete ref;
+ }
+}
+
+file_iterator file_iterator::operator++(int)
+{
+ file_iterator temp(*this);
+ next();
+ return temp;
+}
+
+
+void file_iterator::next()
+{
+ if(ref->hf != _fi_invalid_handle)
+ {
+ bool cont = true;
+ while(cont)
+ {
+ cont = find_next_file(ref->hf, ref->_data);
+ if(cont && ((ref->_data.dwFileAttributes & _fi_dir) == 0))
+ break;
+ }
+ if(!cont)
+ {
+ // end of sequence
+ FindClose(ref->hf);
+ ref->hf = _fi_invalid_handle;
+ *_path = 0;
+ ptr = _path;
+ }
+ else
+ copy_find_file_result_with_overflow_check(ref->_data, ptr, MAX_PATH - (ptr - _path));
+ }
+}
+
+
+
+directory_iterator::directory_iterator()
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ ptr = _path;
+ *_path = 0;
+ *_root = 0;
+ ref = new file_iterator_ref();
+ BOOST_REGEX_NOEH_ASSERT(ref)
+ ref->hf = _fi_invalid_handle;
+ ref->count = 1;
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ delete ref;
+ throw;
+ }
+#endif
+}
+
+directory_iterator::directory_iterator(const char* wild)
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, wild));
+ ptr = _root;
+ while(*ptr)++ptr;
+ while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
+
+ if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
+ {
+ _root[1]='\0';
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
+ }
+ else
+ {
+ *ptr = 0;
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
+ if(*_path == 0)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, "."));
+ re_detail::overflow_error_if_not_zero(re_detail::strcat_s(_path, MAX_PATH, _fi_sep));
+ }
+ ptr = _path + std::strlen(_path);
+
+ ref = new file_iterator_ref();
+ BOOST_REGEX_NOEH_ASSERT(ref)
+ ref->count = 1;
+ ref->hf = find_first_file(wild, ref->_data);
+ if(ref->hf == _fi_invalid_handle)
+ {
+ *_path = 0;
+ ptr = _path;
+ }
+ else
+ {
+ copy_find_file_result_with_overflow_check(ref->_data, ptr, MAX_PATH - (ptr - _path));
+ if(((ref->_data.dwFileAttributes & _fi_dir) == 0) || (std::strcmp(ptr, ".") == 0) || (std::strcmp(ptr, "..") == 0))
+ next();
+ }
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ delete ref;
+ throw;
+ }
+#endif
+}
+
+directory_iterator::~directory_iterator()
+{
+ delete[] _root;
+ delete[] _path;
+ if(--(ref->count) == 0)
+ {
+ if(ref->hf != _fi_invalid_handle)
+ FindClose(ref->hf);
+ delete ref;
+ }
+}
+
+directory_iterator::directory_iterator(const directory_iterator& other)
+{
+ _root = _path = 0;
+ ref = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ _root = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_root)
+ _path = new char[MAX_PATH];
+ BOOST_REGEX_NOEH_ASSERT(_path)
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
+ ptr = _path + (other.ptr - other._path);
+ ref = other.ref;
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(...)
+ {
+ delete[] _root;
+ delete[] _path;
+ throw;
+ }
+#endif
+ ++(ref->count);
+}
+
+directory_iterator& directory_iterator::operator=(const directory_iterator& other)
+{
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
+ re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
+ ptr = _path + (other.ptr - other._path);
+ if(--(ref->count) == 0)
+ {
+ if(ref->hf != _fi_invalid_handle)
+ FindClose(ref->hf);
+ delete ref;
+ }
+ ref = other.ref;
+ ++(ref->count);
+ return *this;
+}
+
+directory_iterator directory_iterator::operator++(int)
+{
+ directory_iterator temp(*this);
+ next();
+ return temp;
+}
+
+void directory_iterator::next()
+{
+ if(ref->hf != _fi_invalid_handle)
+ {
+ bool cont = true;
+ while(cont)
+ {
+ cont = find_next_file(ref->hf, ref->_data);
+ if(cont && (ref->_data.dwFileAttributes & _fi_dir))
+ {
+ if(is_not_current_or_parent_path_string(ref->_data))
+ break;
+ }
+ }
+ if(!cont)
+ {
+ // end of sequence
+ FindClose(ref->hf);
+ ref->hf = _fi_invalid_handle;
+ *_path = 0;
+ ptr = _path;
+ }
+ else
+ copy_find_file_result_with_overflow_check(ref->_data, ptr, MAX_PATH - (ptr - _path));
+ }
+}
+
+
+#ifdef BOOST_REGEX_FI_POSIX_DIR
+
+struct _fi_priv_data
+{
+ char root[MAX_PATH];
+ char* mask;
+ DIR* d;
+ _fi_priv_data(const char* p);
+};
+
+_fi_priv_data::_fi_priv_data(const char* p)
+{
+ std::strcpy(root, p);
+ mask = root;
+ while(*mask) ++mask;
+ while((mask > root) && (*mask != *_fi_sep) && (*mask != *_fi_sep_alt)) --mask;
+ if(mask == root && ((*mask== *_fi_sep) || (*mask == *_fi_sep_alt)) )
+ {
+ root[1] = '\0';
+ std::strcpy(root+2, p+1);
+ mask = root+2;
+ }
+ else if(mask == root)
+ {
+ root[0] = '.';
+ root[1] = '\0';
+ std::strcpy(root+2, p);
+ mask = root+2;
+ }
+ else
+ {
+ *mask = 0;
+ ++mask;
+ }
+}
+
+bool iswild(const char* mask, const char* name)
+{
+ while(*mask && *name)
+ {
+ switch(*mask)
+ {
+ case '?':
+ ++name;
+ ++mask;
+ continue;
+ case '*':
+ ++mask;
+ if(*mask == 0)
+ return true;
+ while(*name)
+ {
+ if(iswild(mask, name))
+ return true;
+ ++name;
+ }
+ return false;
+ case '.':
+ if(0 == *name)
+ {
+ ++mask;
+ continue;
+ }
+ // fall through:
+ default:
+ if(BOOST_REGEX_FI_TRANSLATE(*mask) != BOOST_REGEX_FI_TRANSLATE(*name))
+ return false;
+ ++mask;
+ ++name;
+ continue;
+ }
+ }
+ if(*mask != *name)
+ return false;
+ return true;
+}
+
+unsigned _fi_attributes(const char* root, const char* name)
+{
+ char buf[MAX_PATH];
+ if( ( (root[0] == *_fi_sep) || (root[0] == *_fi_sep_alt) ) && (root[1] == '\0') )
+ (std::sprintf)(buf, "%s%s", root, name);
+ else
+ (std::sprintf)(buf, "%s%s%s", root, _fi_sep, name);
+ DIR* d = opendir(buf);
+ if(d)
+ {
+ closedir(d);
+ return _fi_dir;
+ }
+ return 0;
+}
+
+_fi_find_handle _fi_FindFirstFile(const char* lpFileName, _fi_find_data* lpFindFileData)
+{
+ _fi_find_handle dat = new _fi_priv_data(lpFileName);
+
+ DIR* h = opendir(dat->root);
+ dat->d = h;
+ if(h != 0)
+ {
+ if(_fi_FindNextFile(dat, lpFindFileData))
+ return dat;
+ }
+ delete dat;
+ return 0;
+}
+
+bool _fi_FindNextFile(_fi_find_handle dat, _fi_find_data* lpFindFileData)
+{
+ dirent* d;
+ do
+ {
+ d = readdir(dat->d);
+ } while(d && !iswild(dat->mask, d->d_name));
+
+ if(d)
+ {
+ std::strcpy(lpFindFileData->cFileName, d->d_name);
+ lpFindFileData->dwFileAttributes = _fi_attributes(dat->root, d->d_name);
+ return true;
+ }
+ return false;
+}
+
+bool _fi_FindClose(_fi_find_handle dat)
+{
+ closedir(dat->d);
+ delete dat;
+ return true;
+}
+
+#endif
+
+} // namespace re_detail
+} // namspace boost
+
+#endif // BOOST_REGEX_NO_FILEITER
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/icu.cpp b/3rdParty/Boost/libs/regex/src/icu.cpp
new file mode 100644
index 0000000..e06c317
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/icu.cpp
@@ -0,0 +1,495 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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 icu.cpp
+ * VERSION see <boost/version.hpp>
+ * DESCRIPTION: Unicode regular expressions on top of the ICU Library.
+ */
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex/config.hpp>
+#ifdef BOOST_HAS_ICU
+#define BOOST_REGEX_ICU_INSTANTIATE
+#include <boost/regex/icu.hpp>
+
+namespace boost{
+
+namespace re_detail{
+
+icu_regex_traits_implementation::string_type icu_regex_traits_implementation::do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const
+{
+ // TODO make thread safe!!!! :
+ typedef u32_to_u16_iterator<const char_type*, ::UChar> itt;
+ itt i(p1), j(p2);
+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+ std::vector< ::UChar> t(i, j);
+#else
+ std::vector< ::UChar> t;
+ while(i != j)
+ t.push_back(*i++);
+#endif
+ ::uint8_t result[100];
+ ::int32_t len;
+ if(t.size())
+ len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), result, sizeof(result));
+ else
+ len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), result, sizeof(result));
+ if(std::size_t(len) > sizeof(result))
+ {
+ scoped_array< ::uint8_t> presult(new ::uint8_t[len+1]);
+ if(t.size())
+ len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), presult.get(), len+1);
+ else
+ len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), presult.get(), len+1);
+ if((0 == presult[len-1]) && (len > 1))
+ --len;
+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+ return string_type(presult.get(), presult.get()+len);
+#else
+ string_type sresult;
+ ::uint8_t const* ia = presult.get();
+ ::uint8_t const* ib = presult.get()+len;
+ while(ia != ib)
+ sresult.push_back(*ia++);
+ return sresult;
+#endif
+ }
+ if((0 == result[len-1]) && (len > 1))
+ --len;
+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+ return string_type(result, result+len);
+#else
+ string_type sresult;
+ ::uint8_t const* ia = result;
+ ::uint8_t const* ib = result+len;
+ while(ia != ib)
+ sresult.push_back(*ia++);
+ return sresult;
+#endif
+}
+
+}
+
+icu_regex_traits::size_type icu_regex_traits::length(const char_type* p)
+{
+ size_type result = 0;
+ while(*p)
+ {
+ ++p;
+ ++result;
+ }
+ return result;
+}
+
+//
+// define our bitmasks:
+//
+const icu_regex_traits::char_class_type icu_regex_traits::mask_blank = icu_regex_traits::char_class_type(1) << offset_blank;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_space = icu_regex_traits::char_class_type(1) << offset_space;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_xdigit = icu_regex_traits::char_class_type(1) << offset_xdigit;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_underscore = icu_regex_traits::char_class_type(1) << offset_underscore;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_unicode = icu_regex_traits::char_class_type(1) << offset_unicode;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_any = icu_regex_traits::char_class_type(1) << offset_any;
+const icu_regex_traits::char_class_type icu_regex_traits::mask_ascii = icu_regex_traits::char_class_type(1) << offset_ascii;
+
+icu_regex_traits::char_class_type icu_regex_traits::lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2)
+{
+ static const ::UChar32 prop_name_table[] = {
+ /* any */ 'a', 'n', 'y',
+ /* ascii */ 'a', 's', 'c', 'i', 'i',
+ /* assigned */ 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',
+ /* c* */ 'c', '*',
+ /* cc */ 'c', 'c',
+ /* cf */ 'c', 'f',
+ /* closepunctuation */ 'c', 'l', 'o', 's', 'e', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* cn */ 'c', 'n',
+ /* co */ 'c', 'o',
+ /* connectorpunctuation */ 'c', 'o', 'n', 'n', 'e', 'c', 't', 'o', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* control */ 'c', 'o', 'n', 't', 'r', 'o', 'l',
+ /* cs */ 'c', 's',
+ /* currencysymbol */ 'c', 'u', 'r', 'r', 'e', 'n', 'c', 'y', 's', 'y', 'm', 'b', 'o', 'l',
+ /* dashpunctuation */ 'd', 'a', 's', 'h', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* decimaldigitnumber */ 'd', 'e', 'c', 'i', 'm', 'a', 'l', 'd', 'i', 'g', 'i', 't', 'n', 'u', 'm', 'b', 'e', 'r',
+ /* enclosingmark */ 'e', 'n', 'c', 'l', 'o', 's', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
+ /* finalpunctuation */ 'f', 'i', 'n', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* format */ 'f', 'o', 'r', 'm', 'a', 't',
+ /* initialpunctuation */ 'i', 'n', 'i', 't', 'i', 'a', 'l', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* l* */ 'l', '*',
+ /* letter */ 'l', 'e', 't', 't', 'e', 'r',
+ /* letternumber */ 'l', 'e', 't', 't', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',
+ /* lineseparator */ 'l', 'i', 'n', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
+ /* ll */ 'l', 'l',
+ /* lm */ 'l', 'm',
+ /* lo */ 'l', 'o',
+ /* lowercaseletter */ 'l', 'o', 'w', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
+ /* lt */ 'l', 't',
+ /* lu */ 'l', 'u',
+ /* m* */ 'm', '*',
+ /* mark */ 'm', 'a', 'r', 'k',
+ /* mathsymbol */ 'm', 'a', 't', 'h', 's', 'y', 'm', 'b', 'o', 'l',
+ /* mc */ 'm', 'c',
+ /* me */ 'm', 'e',
+ /* mn */ 'm', 'n',
+ /* modifierletter */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',
+ /* modifiersymbol */ 'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',
+ /* n* */ 'n', '*',
+ /* nd */ 'n', 'd',
+ /* nl */ 'n', 'l',
+ /* no */ 'n', 'o',
+ /* nonspacingmark */ 'n', 'o', 'n', 's', 'p', 'a', 'c', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
+ /* notassigned */ 'n', 'o', 't', 'a', 's', 's', 'i', 'g', 'n', 'e', 'd',
+ /* number */ 'n', 'u', 'm', 'b', 'e', 'r',
+ /* openpunctuation */ 'o', 'p', 'e', 'n', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* other */ 'o', 't', 'h', 'e', 'r',
+ /* otherletter */ 'o', 't', 'h', 'e', 'r', 'l', 'e', 't', 't', 'e', 'r',
+ /* othernumber */ 'o', 't', 'h', 'e', 'r', 'n', 'u', 'm', 'b', 'e', 'r',
+ /* otherpunctuation */ 'o', 't', 'h', 'e', 'r', 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* othersymbol */ 'o', 't', 'h', 'e', 'r', 's', 'y', 'm', 'b', 'o', 'l',
+ /* p* */ 'p', '*',
+ /* paragraphseparator */ 'p', 'a', 'r', 'a', 'g', 'r', 'a', 'p', 'h', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
+ /* pc */ 'p', 'c',
+ /* pd */ 'p', 'd',
+ /* pe */ 'p', 'e',
+ /* pf */ 'p', 'f',
+ /* pi */ 'p', 'i',
+ /* po */ 'p', 'o',
+ /* privateuse */ 'p', 'r', 'i', 'v', 'a', 't', 'e', 'u', 's', 'e',
+ /* ps */ 'p', 's',
+ /* punctuation */ 'p', 'u', 'n', 'c', 't', 'u', 'a', 't', 'i', 'o', 'n',
+ /* s* */ 's', '*',
+ /* sc */ 's', 'c',
+ /* separator */ 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
+ /* sk */ 's', 'k',
+ /* sm */ 's', 'm',
+ /* so */ 's', 'o',
+ /* spaceseparator */ 's', 'p', 'a', 'c', 'e', 's', 'e', 'p', 'a', 'r', 'a', 't', 'o', 'r',
+ /* spacingcombiningmark */ 's', 'p', 'a', 'c', 'i', 'n', 'g', 'c', 'o', 'm', 'b', 'i', 'n', 'i', 'n', 'g', 'm', 'a', 'r', 'k',
+ /* surrogate */ 's', 'u', 'r', 'r', 'o', 'g', 'a', 't', 'e',
+ /* symbol */ 's', 'y', 'm', 'b', 'o', 'l',
+ /* titlecase */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e',
+ /* titlecaseletter */ 't', 'i', 't', 'l', 'e', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
+ /* uppercaseletter */ 'u', 'p', 'p', 'e', 'r', 'c', 'a', 's', 'e', 'l', 'e', 't', 't', 'e', 'r',
+ /* z* */ 'z', '*',
+ /* zl */ 'z', 'l',
+ /* zp */ 'z', 'p',
+ /* zs */ 'z', 's',
+ };
+
+ static const re_detail::character_pointer_range< ::UChar32> range_data[] = {
+ { prop_name_table+0, prop_name_table+3, }, // any
+ { prop_name_table+3, prop_name_table+8, }, // ascii
+ { prop_name_table+8, prop_name_table+16, }, // assigned
+ { prop_name_table+16, prop_name_table+18, }, // c*
+ { prop_name_table+18, prop_name_table+20, }, // cc
+ { prop_name_table+20, prop_name_table+22, }, // cf
+ { prop_name_table+22, prop_name_table+38, }, // closepunctuation
+ { prop_name_table+38, prop_name_table+40, }, // cn
+ { prop_name_table+40, prop_name_table+42, }, // co
+ { prop_name_table+42, prop_name_table+62, }, // connectorpunctuation
+ { prop_name_table+62, prop_name_table+69, }, // control
+ { prop_name_table+69, prop_name_table+71, }, // cs
+ { prop_name_table+71, prop_name_table+85, }, // currencysymbol
+ { prop_name_table+85, prop_name_table+100, }, // dashpunctuation
+ { prop_name_table+100, prop_name_table+118, }, // decimaldigitnumber
+ { prop_name_table+118, prop_name_table+131, }, // enclosingmark
+ { prop_name_table+131, prop_name_table+147, }, // finalpunctuation
+ { prop_name_table+147, prop_name_table+153, }, // format
+ { prop_name_table+153, prop_name_table+171, }, // initialpunctuation
+ { prop_name_table+171, prop_name_table+173, }, // l*
+ { prop_name_table+173, prop_name_table+179, }, // letter
+ { prop_name_table+179, prop_name_table+191, }, // letternumber
+ { prop_name_table+191, prop_name_table+204, }, // lineseparator
+ { prop_name_table+204, prop_name_table+206, }, // ll
+ { prop_name_table+206, prop_name_table+208, }, // lm
+ { prop_name_table+208, prop_name_table+210, }, // lo
+ { prop_name_table+210, prop_name_table+225, }, // lowercaseletter
+ { prop_name_table+225, prop_name_table+227, }, // lt
+ { prop_name_table+227, prop_name_table+229, }, // lu
+ { prop_name_table+229, prop_name_table+231, }, // m*
+ { prop_name_table+231, prop_name_table+235, }, // mark
+ { prop_name_table+235, prop_name_table+245, }, // mathsymbol
+ { prop_name_table+245, prop_name_table+247, }, // mc
+ { prop_name_table+247, prop_name_table+249, }, // me
+ { prop_name_table+249, prop_name_table+251, }, // mn
+ { prop_name_table+251, prop_name_table+265, }, // modifierletter
+ { prop_name_table+265, prop_name_table+279, }, // modifiersymbol
+ { prop_name_table+279, prop_name_table+281, }, // n*
+ { prop_name_table+281, prop_name_table+283, }, // nd
+ { prop_name_table+283, prop_name_table+285, }, // nl
+ { prop_name_table+285, prop_name_table+287, }, // no
+ { prop_name_table+287, prop_name_table+301, }, // nonspacingmark
+ { prop_name_table+301, prop_name_table+312, }, // notassigned
+ { prop_name_table+312, prop_name_table+318, }, // number
+ { prop_name_table+318, prop_name_table+333, }, // openpunctuation
+ { prop_name_table+333, prop_name_table+338, }, // other
+ { prop_name_table+338, prop_name_table+349, }, // otherletter
+ { prop_name_table+349, prop_name_table+360, }, // othernumber
+ { prop_name_table+360, prop_name_table+376, }, // otherpunctuation
+ { prop_name_table+376, prop_name_table+387, }, // othersymbol
+ { prop_name_table+387, prop_name_table+389, }, // p*
+ { prop_name_table+389, prop_name_table+407, }, // paragraphseparator
+ { prop_name_table+407, prop_name_table+409, }, // pc
+ { prop_name_table+409, prop_name_table+411, }, // pd
+ { prop_name_table+411, prop_name_table+413, }, // pe
+ { prop_name_table+413, prop_name_table+415, }, // pf
+ { prop_name_table+415, prop_name_table+417, }, // pi
+ { prop_name_table+417, prop_name_table+419, }, // po
+ { prop_name_table+419, prop_name_table+429, }, // privateuse
+ { prop_name_table+429, prop_name_table+431, }, // ps
+ { prop_name_table+431, prop_name_table+442, }, // punctuation
+ { prop_name_table+442, prop_name_table+444, }, // s*
+ { prop_name_table+444, prop_name_table+446, }, // sc
+ { prop_name_table+446, prop_name_table+455, }, // separator
+ { prop_name_table+455, prop_name_table+457, }, // sk
+ { prop_name_table+457, prop_name_table+459, }, // sm
+ { prop_name_table+459, prop_name_table+461, }, // so
+ { prop_name_table+461, prop_name_table+475, }, // spaceseparator
+ { prop_name_table+475, prop_name_table+495, }, // spacingcombiningmark
+ { prop_name_table+495, prop_name_table+504, }, // surrogate
+ { prop_name_table+504, prop_name_table+510, }, // symbol
+ { prop_name_table+510, prop_name_table+519, }, // titlecase
+ { prop_name_table+519, prop_name_table+534, }, // titlecaseletter
+ { prop_name_table+534, prop_name_table+549, }, // uppercaseletter
+ { prop_name_table+549, prop_name_table+551, }, // z*
+ { prop_name_table+551, prop_name_table+553, }, // zl
+ { prop_name_table+553, prop_name_table+555, }, // zp
+ { prop_name_table+555, prop_name_table+557, }, // zs
+ };
+
+ static const icu_regex_traits::char_class_type icu_class_map[] = {
+ icu_regex_traits::mask_any, // any
+ icu_regex_traits::mask_ascii, // ascii
+ (0x3FFFFFFFu) & ~(U_GC_CN_MASK), // assigned
+ U_GC_C_MASK, // c*
+ U_GC_CC_MASK, // cc
+ U_GC_CF_MASK, // cf
+ U_GC_PE_MASK, // closepunctuation
+ U_GC_CN_MASK, // cn
+ U_GC_CO_MASK, // co
+ U_GC_PC_MASK, // connectorpunctuation
+ U_GC_CC_MASK, // control
+ U_GC_CS_MASK, // cs
+ U_GC_SC_MASK, // currencysymbol
+ U_GC_PD_MASK, // dashpunctuation
+ U_GC_ND_MASK, // decimaldigitnumber
+ U_GC_ME_MASK, // enclosingmark
+ U_GC_PF_MASK, // finalpunctuation
+ U_GC_CF_MASK, // format
+ U_GC_PI_MASK, // initialpunctuation
+ U_GC_L_MASK, // l*
+ U_GC_L_MASK, // letter
+ U_GC_NL_MASK, // letternumber
+ U_GC_ZL_MASK, // lineseparator
+ U_GC_LL_MASK, // ll
+ U_GC_LM_MASK, // lm
+ U_GC_LO_MASK, // lo
+ U_GC_LL_MASK, // lowercaseletter
+ U_GC_LT_MASK, // lt
+ U_GC_LU_MASK, // lu
+ U_GC_M_MASK, // m*
+ U_GC_M_MASK, // mark
+ U_GC_SM_MASK, // mathsymbol
+ U_GC_MC_MASK, // mc
+ U_GC_ME_MASK, // me
+ U_GC_MN_MASK, // mn
+ U_GC_LM_MASK, // modifierletter
+ U_GC_SK_MASK, // modifiersymbol
+ U_GC_N_MASK, // n*
+ U_GC_ND_MASK, // nd
+ U_GC_NL_MASK, // nl
+ U_GC_NO_MASK, // no
+ U_GC_MN_MASK, // nonspacingmark
+ U_GC_CN_MASK, // notassigned
+ U_GC_N_MASK, // number
+ U_GC_PS_MASK, // openpunctuation
+ U_GC_C_MASK, // other
+ U_GC_LO_MASK, // otherletter
+ U_GC_NO_MASK, // othernumber
+ U_GC_PO_MASK, // otherpunctuation
+ U_GC_SO_MASK, // othersymbol
+ U_GC_P_MASK, // p*
+ U_GC_ZP_MASK, // paragraphseparator
+ U_GC_PC_MASK, // pc
+ U_GC_PD_MASK, // pd
+ U_GC_PE_MASK, // pe
+ U_GC_PF_MASK, // pf
+ U_GC_PI_MASK, // pi
+ U_GC_PO_MASK, // po
+ U_GC_CO_MASK, // privateuse
+ U_GC_PS_MASK, // ps
+ U_GC_P_MASK, // punctuation
+ U_GC_S_MASK, // s*
+ U_GC_SC_MASK, // sc
+ U_GC_Z_MASK, // separator
+ U_GC_SK_MASK, // sk
+ U_GC_SM_MASK, // sm
+ U_GC_SO_MASK, // so
+ U_GC_ZS_MASK, // spaceseparator
+ U_GC_MC_MASK, // spacingcombiningmark
+ U_GC_CS_MASK, // surrogate
+ U_GC_S_MASK, // symbol
+ U_GC_LT_MASK, // titlecase
+ U_GC_LT_MASK, // titlecaseletter
+ U_GC_LU_MASK, // uppercaseletter
+ U_GC_Z_MASK, // z*
+ U_GC_ZL_MASK, // zl
+ U_GC_ZP_MASK, // zp
+ U_GC_ZS_MASK, // zs
+ };
+
+
+ static const re_detail::character_pointer_range< ::UChar32>* ranges_begin = range_data;
+ static const re_detail::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data)/sizeof(range_data[0]));
+
+ re_detail::character_pointer_range< ::UChar32> t = { p1, p2, };
+ const re_detail::character_pointer_range< ::UChar32>* p = std::lower_bound(ranges_begin, ranges_end, t);
+ if((p != ranges_end) && (t == *p))
+ return icu_class_map[p - ranges_begin];
+ return 0;
+}
+
+icu_regex_traits::char_class_type icu_regex_traits::lookup_classname(const char_type* p1, const char_type* p2) const
+{
+ static const char_class_type masks[] =
+ {
+ 0,
+ U_GC_L_MASK | U_GC_ND_MASK,
+ U_GC_L_MASK,
+ mask_blank,
+ U_GC_CC_MASK | U_GC_CF_MASK | U_GC_ZL_MASK | U_GC_ZP_MASK,
+ U_GC_ND_MASK,
+ U_GC_ND_MASK,
+ (0x3FFFFFFFu) & ~(U_GC_CC_MASK | U_GC_CF_MASK | U_GC_CS_MASK | U_GC_CN_MASK | U_GC_Z_MASK),
+ U_GC_LL_MASK,
+ U_GC_LL_MASK,
+ ~(U_GC_C_MASK),
+ U_GC_P_MASK,
+ char_class_type(U_GC_Z_MASK) | mask_space,
+ char_class_type(U_GC_Z_MASK) | mask_space,
+ U_GC_LU_MASK,
+ mask_unicode,
+ U_GC_LU_MASK,
+ char_class_type(U_GC_L_MASK | U_GC_ND_MASK | U_GC_MN_MASK) | mask_underscore,
+ char_class_type(U_GC_L_MASK | U_GC_ND_MASK | U_GC_MN_MASK) | mask_underscore,
+ char_class_type(U_GC_ND_MASK) | mask_xdigit,
+ };
+
+ int id = ::boost::re_detail::get_default_class_id(p1, p2);
+ if(id >= 0)
+ return masks[id+1];
+ char_class_type result = lookup_icu_mask(p1, p2);
+ if(result != 0)
+ return result;
+
+ if(id < 0)
+ {
+ string_type s(p1, p2);
+ string_type::size_type i = 0;
+ while(i < s.size())
+ {
+ s[i] = static_cast<char>((::u_tolower)(s[i]));
+ if(::u_isspace(s[i]) || (s[i] == '-') || (s[i] == '_'))
+ s.erase(s.begin()+i, s.begin()+i+1);
+ else
+ {
+ s[i] = static_cast<char>((::u_tolower)(s[i]));
+ ++i;
+ }
+ }
+ if(s.size())
+ id = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+ if(id >= 0)
+ return masks[id+1];
+ if(s.size())
+ result = lookup_icu_mask(&*s.begin(), &*s.begin() + s.size());
+ if(result != 0)
+ return result;
+ }
+ BOOST_ASSERT(std::size_t(id+1) < sizeof(masks) / sizeof(masks[0]));
+ return masks[id+1];
+}
+
+icu_regex_traits::string_type icu_regex_traits::lookup_collatename(const char_type* p1, const char_type* p2) const
+{
+ string_type result;
+ if(std::find_if(p1, p2, std::bind2nd(std::greater< ::UChar32>(), 0x7f)) == p2)
+ {
+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+ std::string s(p1, p2);
+#else
+ std::string s;
+ const char_type* p3 = p1;
+ while(p3 != p2)
+ s.append(1, *p3++);
+#endif
+ // Try Unicode name:
+ UErrorCode err = U_ZERO_ERROR;
+ UChar32 c = ::u_charFromName(U_UNICODE_CHAR_NAME, s.c_str(), &err);
+ if(U_SUCCESS(err))
+ {
+ result.push_back(c);
+ return result;
+ }
+ // Try Unicode-extended name:
+ err = U_ZERO_ERROR;
+ c = ::u_charFromName(U_EXTENDED_CHAR_NAME, s.c_str(), &err);
+ if(U_SUCCESS(err))
+ {
+ result.push_back(c);
+ return result;
+ }
+ // try POSIX name:
+ s = ::boost::re_detail::lookup_default_collate_name(s);
+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+ result.assign(s.begin(), s.end());
+#else
+ result.clear();
+ std::string::const_iterator si, sj;
+ si = s.begin();
+ sj = s.end();
+ while(si != sj)
+ result.push_back(*si++);
+#endif
+ }
+ if(result.empty() && (p2-p1 == 1))
+ result.push_back(*p1);
+ return result;
+}
+
+bool icu_regex_traits::isctype(char_type c, char_class_type f) const
+{
+ // check for standard catagories first:
+ char_class_type m = char_class_type(1u << u_charType(c));
+ if((m & f) != 0)
+ return true;
+ // now check for special cases:
+ if(((f & mask_blank) != 0) && u_isblank(c))
+ return true;
+ if(((f & mask_space) != 0) && u_isspace(c))
+ return true;
+ if(((f & mask_xdigit) != 0) && (u_digit(c, 16) >= 0))
+ return true;
+ if(((f & mask_unicode) != 0) && (c >= 0x100))
+ return true;
+ if(((f & mask_underscore) != 0) && (c == '_'))
+ return true;
+ if(((f & mask_any) != 0) && (c <= 0x10FFFF))
+ return true;
+ if(((f & mask_ascii) != 0) && (c <= 0x7F))
+ return true;
+ return false;
+}
+
+}
+
+#endif // BOOST_HAS_ICU
diff --git a/3rdParty/Boost/libs/regex/src/instances.cpp b/3rdParty/Boost/libs/regex/src/instances.cpp
new file mode 100644
index 0000000..69d72ad
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/instances.cpp
@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: instances.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: regex narrow character template instances.
+ */
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex/config.hpp>
+
+#if !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES)
+#define BOOST_REGEX_NARROW_INSTANTIATE
+
+#ifdef __BORLANDC__
+#pragma hrdstop
+#endif
+
+#include <boost/regex.hpp>
+
+#endif
diff --git a/3rdParty/Boost/libs/regex/src/posix_api.cpp b/3rdParty/Boost/libs/regex/src/posix_api.cpp
new file mode 100644
index 0000000..1564ced
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/posix_api.cpp
@@ -0,0 +1,288 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: posix_api.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements the Posix API wrappers.
+ */
+
+#define BOOST_REGEX_SOURCE
+
+#include <cstdio>
+#include <boost/regex.hpp>
+#include <boost/cregex.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::sprintf;
+ using ::strcpy;
+ using ::strcmp;
+}
+#endif
+
+
+namespace boost{
+
+namespace{
+
+unsigned int magic_value = 25631;
+
+const char* names[] = {
+ "REG_NOERROR",
+ "REG_NOMATCH",
+ "REG_BADPAT",
+ "REG_ECOLLATE",
+ "REG_ECTYPE",
+ "REG_EESCAPE",
+ "REG_ESUBREG",
+ "REG_EBRACK",
+ "REG_EPAREN",
+ "REG_EBRACE",
+ "REG_BADBR",
+ "REG_ERANGE",
+ "REG_ESPACE",
+ "REG_BADRPT",
+ "REG_EEND",
+ "REG_ESIZE",
+ "REG_ERPAREN",
+ "REG_EMPTY",
+ "REG_ECOMPLEXITY",
+ "REG_ESTACK",
+ "REG_E_UNKNOWN",
+};
+} // namespace
+
+typedef boost::basic_regex<char, c_regex_traits<char> > c_regex_type;
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA* expression, const char* ptr, int f)
+{
+ if(expression->re_magic != magic_value)
+ {
+ expression->guts = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ expression->guts = new c_regex_type();
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch(...)
+ {
+ return REG_ESPACE;
+ }
+#else
+ if(0 == expression->guts)
+ return REG_E_MEMORY;
+#endif
+ }
+ // set default flags:
+ boost::uint_fast32_t flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? regex::extended : regex::basic);
+ expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : match_default;
+ // and translate those that are actually set:
+
+ if(f & REG_NOCOLLATE)
+ {
+ flags |= regex::nocollate;
+#ifndef BOOST_REGEX_V3
+ flags &= ~regex::collate;
+#endif
+ }
+
+ if(f & REG_NOSUB)
+ {
+ //expression->eflags |= match_any;
+ flags |= regex::nosubs;
+ }
+
+ if(f & REG_NOSPEC)
+ flags |= regex::literal;
+ if(f & REG_ICASE)
+ flags |= regex::icase;
+ if(f & REG_ESCAPE_IN_LISTS)
+ flags &= ~regex::no_escape_in_lists;
+ if(f & REG_NEWLINE_ALT)
+ flags |= regex::newline_alt;
+
+ const char* p2;
+ if(f & REG_PEND)
+ p2 = expression->re_endp;
+ else p2 = ptr + std::strlen(ptr);
+
+ int result;
+
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ expression->re_magic = magic_value;
+ static_cast<c_regex_type*>(expression->guts)->set_expression(ptr, p2, flags);
+ expression->re_nsub = static_cast<c_regex_type*>(expression->guts)->mark_count() - 1;
+ result = static_cast<c_regex_type*>(expression->guts)->error_code();
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(const boost::regex_error& be)
+ {
+ result = be.code();
+ }
+ catch(...)
+ {
+ result = REG_E_UNKNOWN;
+ }
+#endif
+ if(result)
+ regfreeA(expression);
+ return result;
+
+}
+
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA* e, char* buf, regsize_t buf_size)
+{
+ std::size_t result = 0;
+ if(code & REG_ITOA)
+ {
+ code &= ~REG_ITOA;
+ if(code <= (int)REG_E_UNKNOWN)
+ {
+ result = std::strlen(names[code]) + 1;
+ if(buf_size >= result)
+ re_detail::strcpy_s(buf, buf_size, names[code]);
+ return result;
+ }
+ return result;
+ }
+ if(code == REG_ATOI)
+ {
+ char localbuf[5];
+ if(e == 0)
+ return 0;
+ for(int i = 0; i <= (int)REG_E_UNKNOWN; ++i)
+ {
+ if(std::strcmp(e->re_endp, names[i]) == 0)
+ {
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ (::sprintf_s)(localbuf, 5, "%d", i);
+#else
+ (std::sprintf)(localbuf, "%d", i);
+#endif
+ if(std::strlen(localbuf) < buf_size)
+ re_detail::strcpy_s(buf, buf_size, localbuf);
+ return std::strlen(localbuf) + 1;
+ }
+ }
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ (::sprintf_s)(localbuf, 5, "%d", 0);
+#else
+ (std::sprintf)(localbuf, "%d", 0);
+#endif
+ if(std::strlen(localbuf) < buf_size)
+ re_detail::strcpy_s(buf, buf_size, localbuf);
+ return std::strlen(localbuf) + 1;
+ }
+ if(code <= (int)REG_E_UNKNOWN)
+ {
+ std::string p;
+ if((e) && (e->re_magic == magic_value))
+ p = static_cast<c_regex_type*>(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
+ else
+ {
+ p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
+ }
+ std::size_t len = p.size();
+ if(len < buf_size)
+ {
+ re_detail::strcpy_s(buf, buf_size, p.c_str());
+ }
+ return len + 1;
+ }
+ if(buf_size)
+ *buf = 0;
+ return 0;
+}
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA* expression, const char* buf, regsize_t n, regmatch_t* array, int eflags)
+{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4267)
+#endif
+ bool result = false;
+ match_flag_type flags = match_default | expression->eflags;
+ const char* end;
+ const char* start;
+ cmatch m;
+
+ if(eflags & REG_NOTBOL)
+ flags |= match_not_bol;
+ if(eflags & REG_NOTEOL)
+ flags |= match_not_eol;
+ if(eflags & REG_STARTEND)
+ {
+ start = buf + array[0].rm_so;
+ end = buf + array[0].rm_eo;
+ }
+ else
+ {
+ start = buf;
+ end = buf + std::strlen(buf);
+ }
+
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ if(expression->re_magic == magic_value)
+ {
+ result = regex_search(start, end, m, *static_cast<c_regex_type*>(expression->guts), flags);
+ }
+ else
+ return result;
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch(...)
+ {
+ return REG_E_UNKNOWN;
+ }
+#endif
+
+ if(result)
+ {
+ // extract what matched:
+ std::size_t i;
+ for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
+ {
+ array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
+ array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
+ }
+ // and set anything else to -1:
+ for(i = expression->re_nsub + 1; i < n; ++i)
+ {
+ array[i].rm_so = -1;
+ array[i].rm_eo = -1;
+ }
+ return 0;
+ }
+ return REG_NOMATCH;
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+}
+
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA* expression)
+{
+ if(expression->re_magic == magic_value)
+ {
+ delete static_cast<c_regex_type*>(expression->guts);
+ }
+ expression->re_magic = 0;
+}
+
+} // namespace boost
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/regex.cpp b/3rdParty/Boost/libs/regex/src/regex.cpp
new file mode 100644
index 0000000..0a50382
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/regex.cpp
@@ -0,0 +1,239 @@
+/*
+ *
+ * Copyright (c) 1998-2004
+ * 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.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Misc boost::regbase member funnctions.
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <new>
+#include <boost/regex.hpp>
+#include <boost/throw_exception.hpp>
+
+#if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && defined(_MSC_VER) && (_MSC_VER >= 1300)
+# include <malloc.h>
+#endif
+#ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+# define NOMINMAX
+#endif
+#define NOGDI
+#define NOUSER
+#include <windows.h>
+#endif
+
+#if defined(BOOST_REGEX_NON_RECURSIVE) && !defined(BOOST_REGEX_V3)
+#if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
+#include <new>
+#else
+#include <boost/regex/v4/mem_block_cache.hpp>
+#endif
+#endif
+
+
+namespace boost{
+
+//
+// fix: these are declared out of line here to ensure
+// that dll builds contain the Virtual table for these
+// types - this ensures that exceptions can be thrown
+// from the dll and caught in an exe.
+regex_error::regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos)
+ : std::runtime_error(s)
+ , m_error_code(err)
+ , m_position(pos)
+{
+}
+
+regex_error::regex_error(regex_constants::error_type err)
+ : std::runtime_error(::boost::re_detail::get_default_error_string(err))
+ , m_error_code(err)
+ , m_position(0)
+{
+}
+
+regex_error::~regex_error() throw()
+{
+}
+
+void regex_error::raise()const
+{
+#ifndef BOOST_NO_EXCEPTIONS
+ ::boost::throw_exception(*this);
+#endif
+}
+
+
+
+namespace re_detail{
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex)
+{
+ ::boost::throw_exception(ex);
+}
+//
+// error checking API:
+//
+BOOST_REGEX_DECL void BOOST_REGEX_CALL verify_options(boost::regex::flag_type /*ef*/, match_flag_type mf)
+{
+#ifndef BOOST_REGEX_V3
+ //
+ // can't mix match_extra with POSIX matching rules:
+ //
+ if((mf & match_extra) && (mf & match_posix))
+ {
+ std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules");
+ throw_exception(msg);
+ }
+#endif
+}
+
+#ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+
+static void execute_eror()
+{
+ // we only get here after a stack overflow,
+ // this has to be a separate proceedure because we
+ // can't mix __try{}__except block with local objects
+ // that have destructors:
+ reset_stack_guard_page();
+ std::runtime_error err("Out of stack space, while attempting to match a regular expression.");
+ raise_runtime_error(err);
+}
+
+bool BOOST_REGEX_CALL abstract_protected_call::execute()const
+{
+ __try{
+ return this->call();
+ }__except(EXCEPTION_STACK_OVERFLOW == GetExceptionCode())
+ {
+ execute_eror();
+ }
+ // We never really get here at all:
+ return false;
+}
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page()
+{
+#if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && defined(_MSC_VER) && (_MSC_VER >= 1300)
+ _resetstkoflw();
+#else
+ //
+ // We need to locate the current page being used by the stack,
+ // move to the page below it and then deallocate and protect
+ // that page. Note that ideally we would protect only the lowest
+ // stack page that has been allocated: in practice there
+ // seems to be no easy way to locate this page, in any case as
+ // long as the next page is protected, then Windows will figure
+ // the rest out for us...
+ //
+ SYSTEM_INFO si;
+ GetSystemInfo(&si);
+ MEMORY_BASIC_INFORMATION mi;
+ DWORD previous_protection_status;
+ //
+ // this is an address in our stack space:
+ //
+ LPBYTE page = (LPBYTE)&page;
+ //
+ // Get the current memory page in use:
+ //
+ VirtualQuery(page, &mi, sizeof(mi));
+ //
+ // Go to the page one below this:
+ //
+ page = (LPBYTE)(mi.BaseAddress)-si.dwPageSize;
+ //
+ // Free and protect everything from the start of the
+ // allocation range, to the end of the page below the
+ // one in use:
+ //
+ if (!VirtualFree(mi.AllocationBase, (LPBYTE)page - (LPBYTE)mi.AllocationBase, MEM_DECOMMIT)
+ || !VirtualProtect(page, si.dwPageSize, PAGE_GUARD | PAGE_READWRITE, &previous_protection_status))
+ {
+ throw std::bad_exception();
+ }
+#endif
+}
+#endif
+
+#if defined(BOOST_REGEX_NON_RECURSIVE) && !defined(BOOST_REGEX_V3)
+
+#if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
+
+BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block()
+{
+ return ::operator new(BOOST_REGEX_BLOCKSIZE);
+}
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
+{
+ ::operator delete(p);
+}
+
+#else
+
+#ifdef BOOST_HAS_THREADS
+mem_block_cache block_cache = { 0, 0, BOOST_STATIC_MUTEX_INIT, };
+#else
+mem_block_cache block_cache = { 0, 0, };
+#endif
+
+BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block()
+{
+ return block_cache.get();
+}
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
+{
+ block_cache.put(p);
+}
+
+#endif
+
+#endif
+
+} // namespace re_detail
+
+
+
+} // namespace boost
+
+#if defined(BOOST_RE_USE_VCL) && defined(BOOST_REGEX_DYN_LINK)
+
+int WINAPI DllEntryPoint(HINSTANCE , unsigned long , void*)
+{
+ return 1;
+}
+#endif
+
+#if defined(__IBMCPP__) && defined(BOOST_REGEX_DYN_LINK)
+//
+// Is this correct - linker complains without it ?
+//
+int main()
+{
+ return 0;
+}
+
+#endif
+
+
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/regex_debug.cpp b/3rdParty/Boost/libs/regex/src/regex_debug.cpp
new file mode 100644
index 0000000..9306a82
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/regex_debug.cpp
@@ -0,0 +1,59 @@
+/*
+ *
+ * Copyright (c) 1998-2004
+ * 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_debug.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Misc. debugging helpers.
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex/config.hpp>
+
+
+//
+// regex configuration information: this prints out the settings used
+// when the library was built - include in debugging builds only:
+//
+#ifdef BOOST_REGEX_CONFIG_INFO
+
+#define print_macro regex_lib_print_macro
+#define print_expression regex_lib_print_expression
+#define print_byte_order regex_lib_print_byte_order
+#define print_sign regex_lib_print_sign
+#define print_compiler_macros regex_lib_print_compiler_macros
+#define print_stdlib_macros regex_lib_print_stdlib_macros
+#define print_platform_macros regex_lib_print_platform_macros
+#define print_boost_macros regex_lib_print_boost_macros
+#define print_separator regex_lib_print_separator
+#define OLD_MAIN regex_lib_main
+#define NEW_MAIN regex_lib_main2
+#define NO_RECURSE
+
+#include <libs/regex/test/config_info/regex_config_info.cpp>
+
+BOOST_REGEX_DECL void BOOST_REGEX_CALL print_regex_library_info()
+{
+ std::cout << "\n\n";
+ print_separator();
+ std::cout << "Regex library build configuration:\n\n";
+ regex_lib_main2();
+}
+
+#endif
+
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/regex_raw_buffer.cpp b/3rdParty/Boost/libs/regex/src/regex_raw_buffer.cpp
new file mode 100644
index 0000000..7a8de80
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/regex_raw_buffer.cpp
@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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_raw_buffer.cpp
+ * VERSION see <boost/version.hpp>
+ * DESCRIPTION: Member functions for class raw_storage.
+ */
+
+
+#define BOOST_REGEX_SOURCE
+#include <memory>
+#include <cstring>
+#include <boost/assert.hpp>
+#include <boost/regex/v4/regex_raw_buffer.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+ using ::memmove;
+}
+#endif
+
+
+namespace boost{ namespace re_detail{
+
+void BOOST_REGEX_CALL raw_storage::resize(size_type n)
+{
+ register size_type newsize = start ? last - start : 1024;
+ while(newsize < n)
+ newsize *= 2;
+ register size_type datasize = end - start;
+ // extend newsize to WORD/DWORD boundary:
+ newsize = (newsize + padding_mask) & ~(padding_mask);
+
+ // allocate and copy data:
+ register pointer ptr = static_cast<pointer>(::operator new(newsize));
+ BOOST_REGEX_NOEH_ASSERT(ptr)
+ 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 raw_storage::insert(size_type pos, size_type n)
+{
+ BOOST_ASSERT(pos <= size_type(end - start));
+ if(size_type(last - end) < n)
+ resize(n + (end - start));
+ register void* result = start + pos;
+ std::memmove(start + pos + n, start + pos, (end - start) - pos);
+ end += n;
+ return result;
+}
+
+}} // namespaces
diff --git a/3rdParty/Boost/libs/regex/src/regex_traits_defaults.cpp b/3rdParty/Boost/libs/regex/src/regex_traits_defaults.cpp
new file mode 100644
index 0000000..8f76c09
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/regex_traits_defaults.cpp
@@ -0,0 +1,688 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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_defaults.cpp
+ * 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>
+
+#include <cctype>
+#ifndef BOOST_NO_WREGEX
+#include <cwctype>
+#endif
+
+#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 re_detail{
+
+BOOST_REGEX_DECL 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",
+ };
+
+ 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)
+{
+ static const char* const s_default_error_messages[] = {
+ "Success", /* REG_NOERROR */
+ "No match", /* REG_NOMATCH */
+ "Invalid regular expression", /* REG_BADPAT */
+ "Invalid collation character", /* REG_ECOLLATE */
+ "Invalid character class name", /* REG_ECTYPE */
+ "Invalid or trailing backslash", /* REG_EESCAPE */
+ "Invalid back reference", /* REG_ESUBREG */
+ "Unmatched [ or [^", /* REG_EBRACK */
+ "Unmatched ( or \\(", /* REG_EPAREN */
+ "Unmatched { or \\{", /* REG_EBRACE */
+ "Invalid content of repeat range", /* REG_BADBR */
+ "Invalid range end", /* REG_ERANGE */
+ "Memory exhausted", /* REG_ESPACE */
+ "Invalid preceding regular expression", /* REG_BADRPT */
+ "Premature end of regular expression", /* REG_EEND */
+ "Regular expression too big", /* REG_ESIZE */
+ "Unmatched ) or \\)", /* REG_ERPAREN */
+ "Empty expression", /* REG_EMPTY */
+ "Complexity requirements exceeded", /* REG_ECOMPLEXITY */
+ "Out of stack space", /* REG_ESTACK */
+ "Unknown error", /* REG_E_UNKNOWN */
+ "",
+ "",
+ "",
+ };
+
+ 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);
+}
+#endif
+
+#endif
+
+BOOST_REGEX_DECL 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_not_class, /*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_not_class, /*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_class, /*g*/
+ regex_constants::escape_type_class, /*h*/
+ regex_constants::escape_type_class, /*i*/
+ regex_constants::escape_type_class, /*j*/
+ regex_constants::escape_type_class, /*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::syntax_char, /*'*/
+ 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];
+}
+
+
+} // re_detail
+} // boost
diff --git a/3rdParty/Boost/libs/regex/src/static_mutex.cpp b/3rdParty/Boost/libs/regex/src/static_mutex.cpp
new file mode 100644
index 0000000..cef7678
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/static_mutex.cpp
@@ -0,0 +1,179 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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 static_mutex.cpp
+ * VERSION see <boost/version.hpp>
+ * DESCRIPTION: Declares static_mutex lock type.
+ */
+
+#define BOOST_REGEX_SOURCE
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_THREADS
+
+#include <boost/regex/pending/static_mutex.hpp>
+
+#if defined(BOOST_HAS_WINTHREADS)
+#ifndef NOMINMAX
+# define NOMINMAX
+#endif
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <boost/static_assert.hpp>
+#endif
+
+
+namespace boost{
+
+#if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)
+
+scoped_static_mutex_lock::scoped_static_mutex_lock(static_mutex& m, bool lk)
+: m_mutex(m), m_have_lock(false)
+{
+ if(lk)
+ lock();
+}
+
+scoped_static_mutex_lock::~scoped_static_mutex_lock()
+{
+ if(m_have_lock)
+ unlock();
+}
+
+void scoped_static_mutex_lock::lock()
+{
+ if(0 == m_have_lock)
+ {
+ pthread_mutex_lock(&(m_mutex.m_mutex));
+ m_have_lock = true;
+ }
+}
+
+void scoped_static_mutex_lock::unlock()
+{
+ if(m_have_lock)
+ {
+ pthread_mutex_unlock(&(m_mutex.m_mutex));
+ m_have_lock = false;
+ }
+}
+
+#elif defined(BOOST_HAS_WINTHREADS)
+
+BOOST_STATIC_ASSERT(sizeof(LONG) == sizeof(boost::int32_t));
+
+scoped_static_mutex_lock::scoped_static_mutex_lock(static_mutex& m, bool lk)
+: m_mutex(m), m_have_lock(false)
+{
+ if(lk)
+ lock();
+}
+
+scoped_static_mutex_lock::~scoped_static_mutex_lock()
+{
+ if(m_have_lock)
+ unlock();
+}
+
+void scoped_static_mutex_lock::lock()
+{
+ if(0 == m_have_lock)
+ {
+#if !defined(InterlockedCompareExchangePointer)
+ while(0 != InterlockedCompareExchange(reinterpret_cast<void**>((boost::uint_least16_t*)&(m_mutex.m_mutex)), (void*)1, 0))
+#else
+ while(0 != InterlockedCompareExchange(reinterpret_cast<LONG*>(&(m_mutex.m_mutex)), 1, 0))
+#endif
+ {
+ Sleep(0);
+ }
+ m_have_lock = true;
+ }
+}
+
+void scoped_static_mutex_lock::unlock()
+{
+ if(m_have_lock)
+ {
+#if !defined(InterlockedCompareExchangePointer)
+ InterlockedExchange((LONG*)&(m_mutex.m_mutex), 0);
+#else
+ InterlockedExchange(reinterpret_cast<LONG*>(&(m_mutex.m_mutex)), 0);
+#endif
+ m_have_lock = false;
+ }
+}
+
+#else
+//
+// Portable version of a static mutex based on Boost.Thread library:
+//
+#include <stdlib.h>
+#include <boost/assert.hpp>
+
+boost::recursive_mutex* static_mutex::m_pmutex = 0;
+boost::once_flag static_mutex::m_once = BOOST_ONCE_INIT;
+
+extern "C" BOOST_REGEX_DECL void free_static_mutex()
+{
+ delete static_mutex::m_pmutex;
+ static_mutex::m_pmutex = 0;
+}
+
+void static_mutex::init()
+{
+ m_pmutex = new boost::recursive_mutex();
+ int r = atexit(free_static_mutex);
+ BOOST_ASSERT(0 == r);
+}
+
+scoped_static_mutex_lock::scoped_static_mutex_lock(static_mutex& , bool lk)
+: m_plock(0), m_have_lock(false)
+{
+ if(lk)
+ lock();
+}
+
+scoped_static_mutex_lock::~scoped_static_mutex_lock()
+{
+ if(m_have_lock)
+ unlock();
+ delete m_plock;
+}
+
+void scoped_static_mutex_lock::lock()
+{
+ if(0 == m_have_lock)
+ {
+ boost::call_once(static_mutex::m_once,&static_mutex::init);
+ if(0 == m_plock)
+ m_plock = new boost::recursive_mutex::scoped_lock(*static_mutex::m_pmutex, false);
+ m_plock->lock();
+ m_have_lock = true;
+ }
+}
+
+void scoped_static_mutex_lock::unlock()
+{
+ if(m_have_lock)
+ {
+ m_plock->unlock();
+ m_have_lock = false;
+ }
+}
+
+#endif
+
+}
+
+#endif // BOOST_HAS_THREADS
diff --git a/3rdParty/Boost/libs/regex/src/usinstances.cpp b/3rdParty/Boost/libs/regex/src/usinstances.cpp
new file mode 100644
index 0000000..5665366
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/usinstances.cpp
@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: winstances.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: regex unsigned short template instances (MSVC only).
+ */
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/detail/workaround.hpp>
+#include <memory>
+#include <string>
+
+#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE) && defined(_NATIVE_WCHAR_T_DEFINED) \
+ && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) || defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
+//
+// This is a horrible workaround, but without declaring these symbols extern we get
+// duplicate symbol errors when linking if the application is built without
+// /Zc:wchar_t
+//
+#ifdef _CRTIMP2_PURE
+# define BOOST_REGEX_STDLIB_DECL _CRTIMP2_PURE
+#else
+# define BOOST_REGEX_STDLIB_DECL _CRTIMP2
+#endif
+
+namespace std{
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+template class BOOST_REGEX_STDLIB_DECL allocator<unsigned short>;
+template class BOOST_REGEX_STDLIB_DECL _String_val<unsigned short, allocator<unsigned short> >;
+template class BOOST_REGEX_STDLIB_DECL basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >;
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
+template<> BOOST_REGEX_STDLIB_DECL std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
+#endif
+
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const unsigned short *,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const unsigned short *);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator<(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator>(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+}
+#endif
+
+#include <boost/regex/config.hpp>
+
+#if !defined(BOOST_NO_WREGEX) && defined(BOOST_REGEX_HAS_OTHER_WCHAR_T) && !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES)
+#define BOOST_REGEX_US_INSTANTIATE
+
+#include <boost/regex.hpp>
+
+#endif
+
+
diff --git a/3rdParty/Boost/libs/regex/src/w32_regex_traits.cpp b/3rdParty/Boost/libs/regex/src/w32_regex_traits.cpp
new file mode 100644
index 0000000..365fccc
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/w32_regex_traits.cpp
@@ -0,0 +1,650 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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 w32_regex_traits.cpp
+ * VERSION see <boost/version.hpp>
+ * DESCRIPTION: Implements w32_regex_traits<char> (and associated helper classes).
+ */
+
+#define BOOST_REGEX_SOURCE
+#include <boost/regex/config.hpp>
+
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+#include <boost/regex/regex_traits.hpp>
+#include <boost/regex/pattern_except.hpp>
+
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+# define NOMINMAX
+#endif
+#define NOGDI
+#include <windows.h>
+
+#if defined(_MSC_VER) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+#pragma comment(lib, "user32.lib")
+#endif
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+ using ::memset;
+}
+#endif
+
+namespace boost{ namespace re_detail{
+
+#ifdef BOOST_NO_ANSI_APIS
+UINT get_code_page_for_locale_id(lcid_type id)
+{
+ WCHAR code_page_string[7];
+ if (::GetLocaleInfoW(id, LOCALE_IDEFAULTANSICODEPAGE, code_page_string, 7) == 0)
+ return 0;
+
+ return static_cast<UINT>(_wtol(code_page_string));
+}
+#endif
+
+
+void w32_regex_traits_char_layer<char>::init()
+{
+ // we need to start by initialising our syntax map so we know which
+ // character is used for which purpose:
+ std::memset(m_char_map, 0, sizeof(m_char_map));
+ cat_type cat;
+ std::string cat_name(w32_regex_traits<char>::get_catalog_name());
+ if(cat_name.size())
+ {
+ cat = ::boost::re_detail::w32_cat_open(cat_name);
+ if(!cat)
+ {
+ std::string m("Unable to open message catalog: ");
+ std::runtime_error err(m + cat_name);
+ ::boost::re_detail::raise_runtime_error(err);
+ }
+ }
+ //
+ // if we have a valid catalog then load our messages:
+ //
+ if(cat)
+ {
+ for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
+ {
+ string_type mss = ::boost::re_detail::w32_cat_get(cat, this->m_locale, i, get_default_syntax(i));
+ for(string_type::size_type j = 0; j < mss.size(); ++j)
+ {
+ m_char_map[static_cast<unsigned char>(mss[j])] = i;
+ }
+ }
+ }
+ else
+ {
+ for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
+ {
+ const char* ptr = get_default_syntax(i);
+ while(ptr && *ptr)
+ {
+ m_char_map[static_cast<unsigned char>(*ptr)] = i;
+ ++ptr;
+ }
+ }
+ }
+ //
+ // finish off by calculating our escape types:
+ //
+ unsigned char i = 'A';
+ do
+ {
+ if(m_char_map[i] == 0)
+ {
+ if(::boost::re_detail::w32_is(this->m_locale, 0x0002u, (char)i))
+ m_char_map[i] = regex_constants::escape_type_class;
+ else if(::boost::re_detail::w32_is(this->m_locale, 0x0001u, (char)i))
+ m_char_map[i] = regex_constants::escape_type_not_class;
+ }
+ }while(0xFF != i++);
+
+ //
+ // fill in lower case map:
+ //
+ char char_map[1 << CHAR_BIT];
+ for(int ii = 0; ii < (1 << CHAR_BIT); ++ii)
+ char_map[ii] = static_cast<char>(ii);
+#ifndef BOOST_NO_ANSI_APIS
+ int r = ::LCMapStringA(this->m_locale, LCMAP_LOWERCASE, char_map, 1 << CHAR_BIT, this->m_lower_map, 1 << CHAR_BIT);
+ BOOST_ASSERT(r != 0);
+#else
+ UINT code_page = get_code_page_for_locale_id(this->m_locale);
+ BOOST_ASSERT(code_page != 0);
+
+ WCHAR wide_char_map[1 << CHAR_BIT];
+ int conv_r = ::MultiByteToWideChar(code_page, 0, char_map, 1 << CHAR_BIT, wide_char_map, 1 << CHAR_BIT);
+ BOOST_ASSERT(conv_r != 0);
+
+ WCHAR wide_lower_map[1 << CHAR_BIT];
+ int r = ::LCMapStringW(this->m_locale, LCMAP_LOWERCASE, wide_char_map, 1 << CHAR_BIT, wide_lower_map, 1 << CHAR_BIT);
+ BOOST_ASSERT(r != 0);
+
+ conv_r = ::WideCharToMultiByte(code_page, 0, wide_lower_map, r, this->m_lower_map, 1 << CHAR_BIT, NULL, NULL);
+ BOOST_ASSERT(conv_r != 0);
+#endif
+ if(r < (1 << CHAR_BIT))
+ {
+ // if we have multibyte characters then not all may have been given
+ // a lower case mapping:
+ for(int jj = r; jj < (1 << CHAR_BIT); ++jj)
+ this->m_lower_map[jj] = static_cast<char>(jj);
+ }
+
+#ifndef BOOST_NO_ANSI_APIS
+ r = ::GetStringTypeExA(this->m_locale, CT_CTYPE1, char_map, 1 << CHAR_BIT, this->m_type_map);
+#else
+ r = ::GetStringTypeExW(this->m_locale, CT_CTYPE1, wide_char_map, 1 << CHAR_BIT, this->m_type_map);
+#endif
+ BOOST_ASSERT(0 != r);
+}
+
+BOOST_REGEX_DECL lcid_type BOOST_REGEX_CALL w32_get_default_locale()
+{
+ return ::GetUserDefaultLCID();
+}
+
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(char c, lcid_type id)
+{
+#ifndef BOOST_NO_ANSI_APIS
+ WORD mask;
+ if(::GetStringTypeExA(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_LOWER))
+ return true;
+ return false;
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if (code_page == 0)
+ return false;
+
+ WCHAR wide_c;
+ if (::MultiByteToWideChar(code_page, 0, &c, 1, &wide_c, 1) == 0)
+ return false;
+
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &wide_c, 1, &mask) && (mask & C1_LOWER))
+ return true;
+ return false;
+#endif
+}
+
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t c, lcid_type id)
+{
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_LOWER))
+ return true;
+ return false;
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type id)
+{
+ WORD mask;
+ wchar_t c = ca;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_LOWER))
+ return true;
+ return false;
+}
+#endif
+
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char c, lcid_type id)
+{
+#ifndef BOOST_NO_ANSI_APIS
+ WORD mask;
+ if(::GetStringTypeExA(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_UPPER))
+ return true;
+ return false;
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if (code_page == 0)
+ return false;
+
+ WCHAR wide_c;
+ if (::MultiByteToWideChar(code_page, 0, &c, 1, &wide_c, 1) == 0)
+ return false;
+
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &wide_c, 1, &mask) && (mask & C1_UPPER))
+ return true;
+ return false;
+#endif
+}
+
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t c, lcid_type id)
+{
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_UPPER))
+ return true;
+ return false;
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type id)
+{
+ WORD mask;
+ wchar_t c = ca;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &c, 1, &mask) && (mask & C1_UPPER))
+ return true;
+ return false;
+}
+#endif
+
+void free_module(void* mod)
+{
+ ::FreeLibrary(static_cast<HMODULE>(mod));
+}
+
+BOOST_REGEX_DECL cat_type BOOST_REGEX_CALL w32_cat_open(const std::string& name)
+{
+#ifndef BOOST_NO_ANSI_APIS
+ cat_type result(::LoadLibraryA(name.c_str()), &free_module);
+ return result;
+#else
+ LPWSTR wide_name = (LPWSTR)_alloca( (name.size() + 1) * sizeof(WCHAR) );
+ if (::MultiByteToWideChar(CP_ACP, 0, name.c_str(), name.size(), wide_name, name.size() + 1) == 0)
+ return cat_type();
+
+ cat_type result(::LoadLibraryW(wide_name), &free_module);
+ return result;
+#endif
+}
+
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::string& def)
+{
+#ifndef BOOST_NO_ANSI_APIS
+ char buf[256];
+ if(0 == ::LoadStringA(
+ static_cast<HMODULE>(cat.get()),
+ i,
+ buf,
+ 256
+ ))
+ {
+ return def;
+ }
+#else
+ WCHAR wbuf[256];
+ int r = ::LoadStringW(
+ static_cast<HMODULE>(cat.get()),
+ i,
+ wbuf,
+ 256
+ );
+ if (r == 0)
+ return def;
+
+ LPSTR buf = (LPSTR)_alloca( (r + 1) * 2 );
+ if (::WideCharToMultiByte(CP_ACP, 0, wbuf, r, buf, (r + 1) * 2, NULL, NULL) == 0)
+ return def;
+#endif
+ return std::string(buf);
+}
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::wstring& def)
+{
+ wchar_t buf[256];
+ if(0 == ::LoadStringW(
+ static_cast<HMODULE>(cat.get()),
+ i,
+ buf,
+ 256
+ ))
+ {
+ return def;
+ }
+ return std::wstring(buf);
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::basic_string<unsigned short>& def)
+{
+ unsigned short buf[256];
+ if(0 == ::LoadStringW(
+ static_cast<HMODULE>(cat.get()),
+ i,
+ (LPWSTR)buf,
+ 256
+ ))
+ {
+ return def;
+ }
+ return std::basic_string<unsigned short>(buf);
+}
+#endif
+#endif
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type id, const char* p1, const char* p2)
+{
+#ifndef BOOST_NO_ANSI_APIS
+ int bytes = ::LCMapStringA(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ 0, // destination buffer
+ 0 // size of destination buffer
+ );
+ if(!bytes)
+ return std::string(p1, p2);
+ std::string result(++bytes, '\0');
+ bytes = ::LCMapStringA(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ &*result.begin(), // destination buffer
+ bytes // size of destination buffer
+ );
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if(code_page == 0)
+ return std::string(p1, p2);
+
+ int src_len = static_cast<int>(p2 - p1);
+ LPWSTR wide_p1 = (LPWSTR)_alloca( (src_len + 1) * 2 );
+ if(::MultiByteToWideChar(code_page, 0, p1, src_len, wide_p1, src_len + 1) == 0)
+ return std::string(p1, p2);
+
+ int bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ wide_p1, // source string
+ src_len, // number of characters in source string
+ 0, // destination buffer
+ 0 // size of destination buffer
+ );
+ if(!bytes)
+ return std::string(p1, p2);
+ std::string result(++bytes, '\0');
+ bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ wide_p1, // source string
+ src_len, // number of characters in source string
+ (LPWSTR)&*result.begin(), // destination buffer
+ bytes // size of destination buffer
+ );
+#endif
+ if(bytes > static_cast<int>(result.size()))
+ return std::string(p1, p2);
+ while(result.size() && result[result.size()-1] == '\0')
+ {
+ result.erase(result.size()-1);
+ }
+ return result;
+}
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type id, const wchar_t* p1, const wchar_t* p2)
+{
+ int bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ 0, // destination buffer
+ 0 // size of destination buffer
+ );
+ if(!bytes)
+ return std::wstring(p1, p2);
+ std::string result(++bytes, '\0');
+ bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ reinterpret_cast<wchar_t*>(&*result.begin()), // destination buffer *of bytes*
+ bytes // size of destination buffer
+ );
+ if(bytes > static_cast<int>(result.size()))
+ return std::wstring(p1, p2);
+ while(result.size() && result[result.size()-1] == L'\0')
+ {
+ result.erase(result.size()-1);
+ }
+ std::wstring r2;
+ for(std::string::size_type i = 0; i < result.size(); ++i)
+ r2.append(1, static_cast<wchar_t>(static_cast<unsigned char>(result[i])));
+ return r2;
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type id, const unsigned short* p1, const unsigned short* p2)
+{
+ int bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ (LPCWSTR)p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ 0, // destination buffer
+ 0 // size of destination buffer
+ );
+ if(!bytes)
+ return std::basic_string<unsigned short>(p1, p2);
+ std::string result(++bytes, '\0');
+ bytes = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_SORTKEY, // mapping transformation type
+ (LPCWSTR)p1, // source string
+ static_cast<int>(p2 - p1), // number of characters in source string
+ reinterpret_cast<wchar_t*>(&*result.begin()), // destination buffer *of bytes*
+ bytes // size of destination buffer
+ );
+ if(bytes > static_cast<int>(result.size()))
+ return std::basic_string<unsigned short>(p1, p2);
+ while(result.size() && result[result.size()-1] == L'\0')
+ {
+ result.erase(result.size()-1);
+ }
+ std::basic_string<unsigned short> r2;
+ for(std::string::size_type i = 0; i < result.size(); ++i)
+ r2.append(1, static_cast<unsigned short>(static_cast<unsigned char>(result[i])));
+ return r2;
+}
+#endif
+#endif
+BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type id)
+{
+ char result[2];
+#ifndef BOOST_NO_ANSI_APIS
+ int b = ::LCMapStringA(
+ id, // locale identifier
+ LCMAP_LOWERCASE, // mapping transformation type
+ &c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if (code_page == 0)
+ return c;
+
+ WCHAR wide_c;
+ if (::MultiByteToWideChar(code_page, 0, &c, 1, &wide_c, 1) == 0)
+ return c;
+
+ WCHAR wide_result;
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_LOWERCASE, // mapping transformation type
+ &wide_c, // source string
+ 1, // number of characters in source string
+ &wide_result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+
+ if (::WideCharToMultiByte(code_page, 0, &wide_result, 1, result, 2, NULL, NULL) == 0)
+ return c;
+#endif
+ return result[0];
+}
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type id)
+{
+ wchar_t result[2];
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_LOWERCASE, // mapping transformation type
+ &c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+ return result[0];
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type id)
+{
+ wchar_t result[2];
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_LOWERCASE, // mapping transformation type
+ (wchar_t const*)&c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+ return result[0];
+}
+#endif
+#endif
+BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_toupper(char c, lcid_type id)
+{
+ char result[2];
+#ifndef BOOST_NO_ANSI_APIS
+ int b = ::LCMapStringA(
+ id, // locale identifier
+ LCMAP_UPPERCASE, // mapping transformation type
+ &c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if(code_page == 0)
+ return c;
+
+ WCHAR wide_c;
+ if (::MultiByteToWideChar(code_page, 0, &c, 1, &wide_c, 1) == 0)
+ return c;
+
+ WCHAR wide_result;
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_UPPERCASE, // mapping transformation type
+ &wide_c, // source string
+ 1, // number of characters in source string
+ &wide_result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+
+ if (::WideCharToMultiByte(code_page, 0, &wide_result, 1, result, 2, NULL, NULL) == 0)
+ return c;
+#endif
+ return result[0];
+}
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_toupper(wchar_t c, lcid_type id)
+{
+ wchar_t result[2];
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_UPPERCASE, // mapping transformation type
+ &c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+ return result[0];
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_toupper(unsigned short c, lcid_type id)
+{
+ wchar_t result[2];
+ int b = ::LCMapStringW(
+ id, // locale identifier
+ LCMAP_UPPERCASE, // mapping transformation type
+ (wchar_t const*)&c, // source string
+ 1, // number of characters in source string
+ result, // destination buffer
+ 1); // size of destination buffer
+ if(b == 0)
+ return c;
+ return result[0];
+}
+#endif
+#endif
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, char c)
+{
+ WORD mask;
+#ifndef BOOST_NO_ANSI_APIS
+ if(::GetStringTypeExA(id, CT_CTYPE1, &c, 1, &mask) && (mask & m & w32_regex_traits_implementation<char>::mask_base))
+ return true;
+#else
+ UINT code_page = get_code_page_for_locale_id(id);
+ if(code_page == 0)
+ return false;
+
+ WCHAR wide_c;
+ if (::MultiByteToWideChar(code_page, 0, &c, 1, &wide_c, 1) == 0)
+ return false;
+
+ if(::GetStringTypeExW(id, CT_CTYPE1, &wide_c, 1, &mask) && (mask & m & w32_regex_traits_implementation<char>::mask_base))
+ return true;
+#endif
+ if((m & w32_regex_traits_implementation<char>::mask_word) && (c == '_'))
+ return true;
+ return false;
+}
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, wchar_t c)
+{
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, &c, 1, &mask) && (mask & m & w32_regex_traits_implementation<wchar_t>::mask_base))
+ return true;
+ if((m & w32_regex_traits_implementation<wchar_t>::mask_word) && (c == '_'))
+ return true;
+ if((m & w32_regex_traits_implementation<wchar_t>::mask_unicode) && (c > 0xff))
+ return true;
+ return false;
+}
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, unsigned short c)
+{
+ WORD mask;
+ if(::GetStringTypeExW(id, CT_CTYPE1, (wchar_t const*)&c, 1, &mask) && (mask & m & w32_regex_traits_implementation<wchar_t>::mask_base))
+ return true;
+ if((m & w32_regex_traits_implementation<wchar_t>::mask_word) && (c == '_'))
+ return true;
+ if((m & w32_regex_traits_implementation<wchar_t>::mask_unicode) && (c > 0xff))
+ return true;
+ return false;
+}
+#endif
+#endif
+
+} // re_detail
+} // boost
+
+#endif
+
diff --git a/3rdParty/Boost/libs/regex/src/wc_regex_traits.cpp b/3rdParty/Boost/libs/regex/src/wc_regex_traits.cpp
new file mode 100644
index 0000000..3640f29
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/wc_regex_traits.cpp
@@ -0,0 +1,313 @@
+/*
+ *
+ * Copyright (c) 2004
+ * 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: wc_regex_traits.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements out of line members for c_regex_traits<wchar_t>
+ */
+
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/detail/workaround.hpp>
+#include <memory>
+#include <string>
+
+#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE) && defined(_NATIVE_WCHAR_T_DEFINED) \
+ && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) || defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
+//
+// This is a horrible workaround, but without declaring these symbols extern we get
+// duplicate symbol errors when linking if the application is built without
+// /Zc:wchar_t
+//
+#ifdef _CRTIMP2_PURE
+# define BOOST_REGEX_STDLIB_DECL _CRTIMP2_PURE
+#else
+# define BOOST_REGEX_STDLIB_DECL _CRTIMP2
+#endif
+
+namespace std{
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+template class BOOST_REGEX_STDLIB_DECL allocator<unsigned short>;
+template class BOOST_REGEX_STDLIB_DECL _String_val<unsigned short, allocator<unsigned short> >;
+template class BOOST_REGEX_STDLIB_DECL basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >;
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
+template<> BOOST_REGEX_STDLIB_DECL std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
+#endif
+
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const unsigned short *,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const unsigned short *);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator<(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+template BOOST_REGEX_STDLIB_DECL bool __cdecl operator>(
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
+ const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
+}
+#endif
+
+#include <boost/regex/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
+
+#include <boost/regex/v4/c_regex_traits.hpp>
+#ifndef BOOST_NO_WREGEX
+#include <boost/regex/v4/primary_transform.hpp>
+#include <boost/regex/v4/regex_traits_defaults.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::wcstol;
+}
+#endif
+
+namespace boost{
+
+c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform(const wchar_t* p1, const wchar_t* p2)
+{
+ std::size_t r;
+ std::size_t s = 10;
+ std::wstring src(p1, p2);
+ std::wstring result(s, L' ');
+ while(s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))
+ {
+ result.append(r - s + 3, L' ');
+ s = result.size();
+ }
+ result.erase(r);
+ return result;
+}
+
+c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2)
+{
+ static wchar_t s_delim;
+ static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
+ std::wstring result;
+ //
+ // What we do here depends upon the format of the sort key returned by
+ // sort key returned by this->transform:
+ //
+ switch(s_collate_type)
+ {
+ case ::boost::re_detail::sort_C:
+ case ::boost::re_detail::sort_unknown:
+ // the best we can do is translate to lower case, then get a regular sort key:
+ {
+ result.assign(p1, p2);
+ for(std::wstring::size_type i = 0; i < result.size(); ++i)
+ result[i] = (std::towlower)(result[i]);
+ result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+ break;
+ }
+ case ::boost::re_detail::sort_fixed:
+ {
+ // get a regular sort key, and then truncate it:
+ result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+ result.erase(s_delim);
+ break;
+ }
+ case ::boost::re_detail::sort_delim:
+ // get a regular sort key, and then truncate everything after the delim:
+ result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
+ if(result.size() && (result[0] == s_delim))
+ break;
+ std::size_t i;
+ for(i = 0; i < result.size(); ++i)
+ {
+ if(result[i] == s_delim)
+ break;
+ }
+ result.erase(i);
+ break;
+ }
+ if(result.empty())
+ result = std::wstring(1, char(0));
+ return result;
+}
+
+enum
+{
+ char_class_space=1<<0,
+ char_class_print=1<<1,
+ char_class_cntrl=1<<2,
+ char_class_upper=1<<3,
+ char_class_lower=1<<4,
+ char_class_alpha=1<<5,
+ char_class_digit=1<<6,
+ char_class_punct=1<<7,
+ char_class_xdigit=1<<8,
+ char_class_alnum=char_class_alpha|char_class_digit,
+ char_class_graph=char_class_alnum|char_class_punct,
+ char_class_blank=1<<9,
+ char_class_word=1<<10,
+ char_class_unicode=1<<11
+};
+
+c_regex_traits<wchar_t>::char_class_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_classname(const wchar_t* p1, const wchar_t* p2)
+{
+ static const char_class_type masks[] =
+ {
+ 0,
+ char_class_alnum,
+ char_class_alpha,
+ char_class_blank,
+ char_class_cntrl,
+ char_class_digit,
+ char_class_digit,
+ char_class_graph,
+ char_class_lower,
+ char_class_lower,
+ char_class_print,
+ char_class_punct,
+ char_class_space,
+ char_class_space,
+ char_class_upper,
+ char_class_unicode,
+ char_class_upper,
+ char_class_alnum | char_class_word,
+ char_class_alnum | char_class_word,
+ char_class_xdigit,
+ };
+
+ int id = ::boost::re_detail::get_default_class_id(p1, p2);
+ if(id < 0)
+ {
+ std::wstring s(p1, p2);
+ for(std::wstring::size_type i = 0; i < s.size(); ++i)
+ s[i] = (std::towlower)(s[i]);
+ id = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+ }
+ BOOST_ASSERT(id+1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));
+ return masks[id+1];
+}
+
+bool BOOST_REGEX_CALL c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_type mask)
+{
+ return
+ ((mask & char_class_space) && (std::iswspace)(c))
+ || ((mask & char_class_print) && (std::iswprint)(c))
+ || ((mask & char_class_cntrl) && (std::iswcntrl)(c))
+ || ((mask & char_class_upper) && (std::iswupper)(c))
+ || ((mask & char_class_lower) && (std::iswlower)(c))
+ || ((mask & char_class_alpha) && (std::iswalpha)(c))
+ || ((mask & char_class_digit) && (std::iswdigit)(c))
+ || ((mask & char_class_punct) && (std::iswpunct)(c))
+ || ((mask & char_class_xdigit) && (std::iswxdigit)(c))
+ || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::re_detail::is_separator(c))
+ || ((mask & char_class_word) && (c == '_'))
+ || ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)));
+}
+
+c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2)
+{
+#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
+ && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
+ && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
+ std::string name(p1, p2);
+#else
+ std::string name;
+ const wchar_t* p0 = p1;
+ while(p0 != p2)
+ name.append(1, char(*p0++));
+#endif
+ name = ::boost::re_detail::lookup_default_collate_name(name);
+#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
+ && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
+ && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
+ if(name.size())
+ return string_type(name.begin(), name.end());
+#else
+ if(name.size())
+ {
+ string_type result;
+ typedef std::string::const_iterator iter;
+ iter b = name.begin();
+ iter e = name.end();
+ while(b != e)
+ result.append(1, wchar_t(*b++));
+ return result;
+ }
+#endif
+ if(p2 - p1 == 1)
+ return string_type(1, *p1);
+ return string_type();
+}
+
+int BOOST_REGEX_CALL c_regex_traits<wchar_t>::value(wchar_t c, int radix)
+{
+#ifdef __BORLANDC__
+ // workaround for broken wcstol:
+ if((std::iswxdigit)(c) == 0)
+ return -1;
+#endif
+ wchar_t b[2] = { c, '\0', };
+ wchar_t* ep;
+ int result = std::wcstol(b, &ep, radix);
+ if(ep == b)
+ return -1;
+ return result;
+}
+
+#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
+c_regex_traits<unsigned short>::string_type BOOST_REGEX_CALL c_regex_traits<unsigned short>::transform(const unsigned short* p1, const unsigned short* p2)
+{
+ std::wstring result = c_regex_traits<wchar_t>::transform((const wchar_t*)p1, (const wchar_t*)p2);
+ return string_type(result.begin(), result.end());
+}
+
+c_regex_traits<unsigned short>::string_type BOOST_REGEX_CALL c_regex_traits<unsigned short>::transform_primary(const unsigned short* p1, const unsigned short* p2)
+{
+ std::wstring result = c_regex_traits<wchar_t>::transform_primary((const wchar_t*)p1, (const wchar_t*)p2);
+ return string_type(result.begin(), result.end());
+}
+
+c_regex_traits<unsigned short>::char_class_type BOOST_REGEX_CALL c_regex_traits<unsigned short>::lookup_classname(const unsigned short* p1, const unsigned short* p2)
+{
+ return c_regex_traits<wchar_t>::lookup_classname((const wchar_t*)p1, (const wchar_t*)p2);
+}
+
+c_regex_traits<unsigned short>::string_type BOOST_REGEX_CALL c_regex_traits<unsigned short>::lookup_collatename(const unsigned short* p1, const unsigned short* p2)
+{
+ std::wstring result = c_regex_traits<wchar_t>::lookup_collatename((const wchar_t*)p1, (const wchar_t*)p2);
+ return string_type(result.begin(), result.end());
+}
+
+bool BOOST_REGEX_CALL c_regex_traits<unsigned short>::isctype(unsigned short c, char_class_type m)
+{
+ return c_regex_traits<wchar_t>::isctype(c, m);
+}
+
+int BOOST_REGEX_CALL c_regex_traits<unsigned short>::value(unsigned short c, int radix)
+{
+ return c_regex_traits<wchar_t>::value(c, radix);
+}
+
+#endif
+
+}
+
+#endif // BOOST_NO_WREGEX
+
+#endif // __BORLANDC__
+
diff --git a/3rdParty/Boost/libs/regex/src/wide_posix_api.cpp b/3rdParty/Boost/libs/regex/src/wide_posix_api.cpp
new file mode 100644
index 0000000..c8a9190
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/wide_posix_api.cpp
@@ -0,0 +1,310 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: wide_posix_api.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: Implements the wide character POSIX API wrappers.
+ */
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex/config.hpp>
+
+#ifndef BOOST_NO_WREGEX
+
+#include <boost/regex.hpp>
+#include <boost/cregex.hpp>
+
+#include <cwchar>
+#include <cstring>
+#include <cstdio>
+
+#if defined(BOOST_NO_STDC_NAMESPACE) || defined(__NetBSD__)
+namespace std{
+# ifndef BOOST_NO_SWPRINTF
+ using ::swprintf;
+# endif
+}
+#endif
+
+
+namespace boost{
+
+namespace {
+
+unsigned int wmagic_value = 28631;
+
+const wchar_t* wnames[] = {
+ L"REG_NOERROR",
+ L"REG_NOMATCH",
+ L"REG_BADPAT",
+ L"REG_ECOLLATE",
+ L"REG_ECTYPE",
+ L"REG_EESCAPE",
+ L"REG_ESUBREG",
+ L"REG_EBRACK",
+ L"REG_EPAREN",
+ L"REG_EBRACE",
+ L"REG_BADBR",
+ L"REG_ERANGE",
+ L"REG_ESPACE",
+ L"REG_BADRPT",
+ L"REG_EEND",
+ L"REG_ESIZE",
+ L"REG_ERPAREN",
+ L"REG_EMPTY",
+ L"REG_ECOMPLEXITY",
+ L"REG_ESTACK",
+ L"REG_E_UNKNOWN",
+};
+}
+
+typedef boost::basic_regex<wchar_t, c_regex_traits<wchar_t> > c_regex_type;
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wchar_t* ptr, int f)
+{
+ if(expression->re_magic != wmagic_value)
+ {
+ expression->guts = 0;
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ expression->guts = new c_regex_type();
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch(...)
+ {
+ return REG_ESPACE;
+ }
+#else
+ if(0 == expression->guts)
+ return REG_E_MEMORY;
+#endif
+ }
+ // set default flags:
+ boost::uint_fast32_t flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? wregex::extended : wregex::basic);
+ expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : match_default;
+
+ // and translate those that are actually set:
+ if(f & REG_NOCOLLATE)
+ {
+ flags |= wregex::nocollate;
+#ifndef BOOST_REGEX_V3
+ flags &= ~wregex::collate;
+#endif
+ }
+
+ if(f & REG_NOSUB)
+ {
+ //expression->eflags |= match_any;
+ flags |= wregex::nosubs;
+ }
+
+ if(f & REG_NOSPEC)
+ flags |= wregex::literal;
+ if(f & REG_ICASE)
+ flags |= wregex::icase;
+ if(f & REG_ESCAPE_IN_LISTS)
+ flags &= ~wregex::no_escape_in_lists;
+ if(f & REG_NEWLINE_ALT)
+ flags |= wregex::newline_alt;
+
+ const wchar_t* p2;
+ if(f & REG_PEND)
+ p2 = expression->re_endp;
+ else p2 = ptr + std::wcslen(ptr);
+
+ int result;
+
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ expression->re_magic = wmagic_value;
+ static_cast<c_regex_type*>(expression->guts)->set_expression(ptr, p2, flags);
+ expression->re_nsub = static_cast<c_regex_type*>(expression->guts)->mark_count() - 1;
+ result = static_cast<c_regex_type*>(expression->guts)->error_code();
+#ifndef BOOST_NO_EXCEPTIONS
+ }
+ catch(const boost::regex_error& be)
+ {
+ result = be.code();
+ }
+ catch(...)
+ {
+ result = REG_E_UNKNOWN;
+ }
+#endif
+ if(result)
+ regfreeW(expression);
+ return result;
+
+}
+
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* e, wchar_t* buf, regsize_t buf_size)
+{
+ std::size_t result = 0;
+ if(code & REG_ITOA)
+ {
+ code &= ~REG_ITOA;
+ if((code <= (int)REG_E_UNKNOWN) && (code >= 0))
+ {
+ result = std::wcslen(wnames[code]) + 1;
+ if(buf_size >= result)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ ::wcscpy_s(buf, buf_size, wnames[code]);
+#else
+ std::wcscpy(buf, wnames[code]);
+#endif
+ return result;
+ }
+ return result;
+ }
+#if !defined(BOOST_NO_SWPRINTF)
+ if(code == REG_ATOI)
+ {
+ wchar_t localbuf[5];
+ if(e == 0)
+ return 0;
+ for(int i = 0; i <= (int)REG_E_UNKNOWN; ++i)
+ {
+ if(std::wcscmp(e->re_endp, wnames[i]) == 0)
+ {
+#if defined(_WIN32_WCE) && !defined(UNDER_CE)
+ (std::swprintf)(localbuf, L"%d", i);
+#else
+ (std::swprintf)(localbuf, 5, L"%d", i);
+#endif
+ if(std::wcslen(localbuf) < buf_size)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ ::wcscpy_s(buf, buf_size, localbuf);
+#else
+ std::wcscpy(buf, localbuf);
+#endif
+ return std::wcslen(localbuf) + 1;
+ }
+ }
+#if defined(_WIN32_WCE) && !defined(UNDER_CE)
+ (std::swprintf)(localbuf, L"%d", 0);
+#else
+ (std::swprintf)(localbuf, 5, L"%d", 0);
+#endif
+ if(std::wcslen(localbuf) < buf_size)
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
+ ::wcscpy_s(buf, buf_size, localbuf);
+#else
+ std::wcscpy(buf, localbuf);
+#endif
+ return std::wcslen(localbuf) + 1;
+ }
+#endif
+ if(code <= (int)REG_E_UNKNOWN)
+ {
+ std::string p;
+ if((e) && (e->re_magic == wmagic_value))
+ p = static_cast<c_regex_type*>(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
+ else
+ {
+ p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
+ }
+ std::size_t len = p.size();
+ if(len < buf_size)
+ {
+ re_detail::copy(p.c_str(), p.c_str() + p.size() + 1, buf);
+ }
+ return len + 1;
+ }
+ if(buf_size)
+ *buf = 0;
+ return 0;
+}
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW* expression, const wchar_t* buf, regsize_t n, regmatch_t* array, int eflags)
+{
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4267)
+#endif
+ bool result = false;
+ match_flag_type flags = match_default | expression->eflags;
+ const wchar_t* end;
+ const wchar_t* start;
+ wcmatch m;
+
+ if(eflags & REG_NOTBOL)
+ flags |= match_not_bol;
+ if(eflags & REG_NOTEOL)
+ flags |= match_not_eol;
+ if(eflags & REG_STARTEND)
+ {
+ start = buf + array[0].rm_so;
+ end = buf + array[0].rm_eo;
+ }
+ else
+ {
+ start = buf;
+ end = buf + std::wcslen(buf);
+ }
+
+#ifndef BOOST_NO_EXCEPTIONS
+ try{
+#endif
+ if(expression->re_magic == wmagic_value)
+ {
+ result = regex_search(start, end, m, *static_cast<c_regex_type*>(expression->guts), flags);
+ }
+ else
+ return result;
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch(...)
+ {
+ return REG_E_UNKNOWN;
+ }
+#endif
+ if(result)
+ {
+ // extract what matched:
+ std::size_t i;
+ for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
+ {
+ array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
+ array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
+ }
+ // and set anything else to -1:
+ for(i = expression->re_nsub + 1; i < n; ++i)
+ {
+ array[i].rm_so = -1;
+ array[i].rm_eo = -1;
+ }
+ return 0;
+ }
+ return REG_NOMATCH;
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+}
+
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW* expression)
+{
+ if(expression->re_magic == wmagic_value)
+ {
+ delete static_cast<c_regex_type*>(expression->guts);
+ }
+ expression->re_magic = 0;
+}
+
+} // namespace boost;
+
+#endif
+
+
+
+
diff --git a/3rdParty/Boost/libs/regex/src/winstances.cpp b/3rdParty/Boost/libs/regex/src/winstances.cpp
new file mode 100644
index 0000000..1e0b859
--- /dev/null
+++ b/3rdParty/Boost/libs/regex/src/winstances.cpp
@@ -0,0 +1,35 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * 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: winstances.cpp
+ * VERSION: see <boost/version.hpp>
+ * DESCRIPTION: regex wide character template instances.
+ */
+
+#define BOOST_REGEX_SOURCE
+
+#include <boost/regex/config.hpp>
+
+#if !defined(BOOST_NO_WREGEX) && !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES)
+#define BOOST_REGEX_WIDE_INSTANTIATE
+
+#ifdef __BORLANDC__
+#pragma hrdstop
+#endif
+
+#include <boost/regex.hpp>
+
+#endif
+
+
+