summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/classic/utility')
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/chset.hpp187
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/chset_operators.hpp402
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp366
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp107
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp246
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.hpp127
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.ipp218
-rw-r--r--3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp666
8 files changed, 2319 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset.hpp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset.hpp
new file mode 100644
index 0000000..3635456
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset.hpp
@@ -0,0 +1,187 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2001-2003 Daniel Nuffer
+ http://spirit.sourceforge.net/
+
+ Distributed under 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_CHSET_HPP
+#define BOOST_SPIRIT_CHSET_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/shared_ptr.hpp>
+#include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
+#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+namespace utility { namespace impl {
+
+ // This is here because some compilers choke on out-of-line member
+ // template functions. And we don't want to put the whole algorithm
+ // in the chset constructor in the class definition.
+ template <typename CharT, typename CharT2>
+ void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
+ CharT2 const* definition);
+
+}} // namespace utility::impl
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chset class
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT = char>
+class chset: public char_parser<chset<CharT> > {
+
+public:
+ chset();
+ chset(chset const& arg_);
+ explicit chset(CharT arg_);
+ explicit chset(anychar_parser arg_);
+ explicit chset(nothing_parser arg_);
+ explicit chset(chlit<CharT> const& arg_);
+ explicit chset(range<CharT> const& arg_);
+ explicit chset(negated_char_parser<chlit<CharT> > const& arg_);
+ explicit chset(negated_char_parser<range<CharT> > const& arg_);
+
+ template <typename CharT2>
+ explicit chset(CharT2 const* definition)
+ : ptr(new basic_chset<CharT>())
+ {
+ utility::impl::construct_chset(ptr, definition);
+ }
+ ~chset();
+
+ chset& operator=(chset const& rhs);
+ chset& operator=(CharT rhs);
+ chset& operator=(anychar_parser rhs);
+ chset& operator=(nothing_parser rhs);
+ chset& operator=(chlit<CharT> const& rhs);
+ chset& operator=(range<CharT> const& rhs);
+ chset& operator=(negated_char_parser<chlit<CharT> > const& rhs);
+ chset& operator=(negated_char_parser<range<CharT> > const& rhs);
+
+ void set(range<CharT> const& arg_);
+ void set(negated_char_parser<chlit<CharT> > const& arg_);
+ void set(negated_char_parser<range<CharT> > const& arg_);
+
+ void clear(range<CharT> const& arg_);
+ void clear(negated_char_parser<range<CharT> > const& arg_);
+ bool test(CharT ch) const;
+ chset& inverse();
+ void swap(chset& x);
+
+ chset& operator|=(chset const& x);
+ chset& operator&=(chset const& x);
+ chset& operator-=(chset const& x);
+ chset& operator^=(chset const& x);
+
+private:
+
+ boost::shared_ptr<basic_chset<CharT> > ptr;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Generator functions
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+chset_p(chlit<CharT> const& arg_)
+{ return chset<CharT>(arg_); }
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+chset_p(range<CharT> const& arg_)
+{ return chset<CharT>(arg_); }
+
+template <typename CharT>
+inline chset<CharT>
+chset_p(negated_char_parser<chlit<CharT> > const& arg_)
+{ return chset<CharT>(arg_); }
+
+template <typename CharT>
+inline chset<CharT>
+chset_p(negated_char_parser<range<CharT> > const& arg_)
+{ return chset<CharT>(arg_); }
+
+//////////////////////////////////
+inline chset<char>
+chset_p(char const* init)
+{ return chset<char>(init); }
+
+//////////////////////////////////
+inline chset<wchar_t>
+chset_p(wchar_t const* init)
+{ return chset<wchar_t>(init); }
+
+//////////////////////////////////
+inline chset<char>
+chset_p(char ch)
+{ return chset<char>(ch); }
+
+//////////////////////////////////
+inline chset<wchar_t>
+chset_p(wchar_t ch)
+{ return chset<wchar_t>(ch); }
+
+//////////////////////////////////
+inline chset<int>
+chset_p(int ch)
+{ return chset<int>(ch); }
+
+//////////////////////////////////
+inline chset<unsigned int>
+chset_p(unsigned int ch)
+{ return chset<unsigned int>(ch); }
+
+//////////////////////////////////
+inline chset<short>
+chset_p(short ch)
+{ return chset<short>(ch); }
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+//////////////////////////////////
+inline chset<unsigned short>
+chset_p(unsigned short ch)
+{ return chset<unsigned short>(ch); }
+#endif
+//////////////////////////////////
+inline chset<long>
+chset_p(long ch)
+{ return chset<long>(ch); }
+
+//////////////////////////////////
+inline chset<unsigned long>
+chset_p(unsigned long ch)
+{ return chset<unsigned long>(ch); }
+
+#ifdef BOOST_HAS_LONG_LONG
+//////////////////////////////////
+inline chset< ::boost::long_long_type>
+chset_p( ::boost::long_long_type ch)
+{ return chset< ::boost::long_long_type>(ch); }
+
+//////////////////////////////////
+inline chset< ::boost::ulong_long_type>
+chset_p( ::boost::ulong_long_type ch)
+{ return chset< ::boost::ulong_long_type>(ch); }
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#endif
+
+#include <boost/spirit/home/classic/utility/impl/chset.ipp>
+#include <boost/spirit/home/classic/utility/chset_operators.hpp>
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset_operators.hpp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset_operators.hpp
new file mode 100644
index 0000000..d42b5fa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/chset_operators.hpp
@@ -0,0 +1,402 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2001-2003 Daniel Nuffer
+ http://spirit.sourceforge.net/
+
+ Distributed under 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_CHSET_OPERATORS_HPP
+#define BOOST_SPIRIT_CHSET_OPERATORS_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/utility/chset.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chset free operators
+//
+// Where a and b are both chsets, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+// Where a is a chset, implements:
+//
+// ~a
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator~(chset<CharT> const& a);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// range <--> chset free operators
+//
+// Where a is a chset and b is a range, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, range<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, range<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, range<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, range<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(range<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(range<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(range<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(range<CharT> const& a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chlit <--> chset free operators
+//
+// Where a is a chset and b is a chlit, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, chlit<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, chlit<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, chlit<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, chlit<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chlit<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chlit<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chlit<CharT> const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chlit<CharT> const& a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// negated_char_parser<range> <--> chset free operators
+//
+// Where a is a chset and b is a range, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// negated_char_parser<chlit> <--> chset free operators
+//
+// Where a is a chset and b is a chlit, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// literal primitives <--> chset free operators
+//
+// Where a is a chset and b is a literal primitive,
+// and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, CharT b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, CharT b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, CharT b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, CharT b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(CharT a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(CharT a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(CharT a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(CharT a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// anychar_parser <--> chset free operators
+//
+// Where a is chset and b is a anychar_parser, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, anychar_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, anychar_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, anychar_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, anychar_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(anychar_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(anychar_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(anychar_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(anychar_parser a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// nothing_parser <--> chset free operators
+//
+// Where a is chset and b is nothing_parser, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(chset<CharT> const& a, nothing_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(chset<CharT> const& a, nothing_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(chset<CharT> const& a, nothing_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(chset<CharT> const& a, nothing_parser b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator|(nothing_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator&(nothing_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator-(nothing_parser a, chset<CharT> const& b);
+
+//////////////////////////////////
+template <typename CharT>
+chset<CharT>
+operator^(nothing_parser a, chset<CharT> const& b);
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#endif
+
+#include <boost/spirit/home/classic/utility/impl/chset_operators.ipp>
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp
new file mode 100644
index 0000000..3017035
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp
@@ -0,0 +1,366 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2001-2003 Daniel Nuffer
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_CHSET_IPP
+#define BOOST_SPIRIT_CHSET_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/limits.hpp>
+#include <boost/spirit/home/classic/utility/chset.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chset class
+//
+///////////////////////////////////////////////////////////////////////////////
+namespace utility { namespace impl {
+ template <typename CharT>
+ inline void
+ detach(boost::shared_ptr<basic_chset<CharT> >& ptr)
+ {
+ if (!ptr.unique())
+ ptr = boost::shared_ptr<basic_chset<CharT> >
+ (new basic_chset<CharT>(*ptr));
+ }
+
+ template <typename CharT>
+ inline void
+ detach_clear(boost::shared_ptr<basic_chset<CharT> >& ptr)
+ {
+ if (ptr.unique())
+ ptr->clear();
+ else
+ ptr.reset(new basic_chset<CharT>());
+ }
+
+ template <typename CharT, typename CharT2>
+ void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
+ CharT2 const* definition)
+ {
+ CharT2 ch = *definition++;
+ while (ch)
+ {
+ CharT2 next = *definition++;
+ if (next == '-')
+ {
+ next = *definition++;
+ if (next == 0)
+ {
+ ptr->set(ch);
+ ptr->set('-');
+ break;
+ }
+ ptr->set(ch, next);
+ }
+ else
+ {
+ ptr->set(ch);
+ }
+ ch = next;
+ }
+ }
+
+ //////////////////////////////////
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+ template <typename CharT, typename FakeT>
+ void chset_negated_set(boost::shared_ptr<basic_chset<CharT> > &ptr, chlit<CharT> const &ch,
+ FakeT)
+ {
+ if(ch.ch != (std::numeric_limits<CharT>::min)()) {
+ ptr->set((std::numeric_limits<CharT>::min)(), ch.ch - 1);
+ }
+ if(ch.ch != (std::numeric_limits<CharT>::max)()) {
+ ptr->set(ch.ch + 1, (std::numeric_limits<CharT>::max)());
+ }
+ }
+
+ template <typename CharT, typename FakeT>
+ void chset_negated_set(boost::shared_ptr<basic_chset<CharT> > &ptr,
+ spirit::range<CharT> const &rng, FakeT)
+ {
+ if(rng.first != (std::numeric_limits<CharT>::min)()) {
+ ptr->set((std::numeric_limits<CharT>::min)(), rng.first - 1);
+ }
+ if(rng.last != (std::numeric_limits<CharT>::max)()) {
+ ptr->set(rng.last + 1, (std::numeric_limits<CharT>::max)());
+ }
+ }
+
+#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+//////////////////////////////////
+
+}} // namespace utility::impl
+
+template <typename CharT>
+inline chset<CharT>::chset()
+: ptr(new basic_chset<CharT>()) {}
+
+template <typename CharT>
+inline chset<CharT>::chset(chset const& arg_)
+: ptr(new basic_chset<CharT>(*arg_.ptr)) {}
+
+template <typename CharT>
+inline chset<CharT>::chset(CharT arg_)
+: ptr(new basic_chset<CharT>())
+{ ptr->set(arg_); }
+
+template <typename CharT>
+inline chset<CharT>::chset(anychar_parser /*arg*/)
+: ptr(new basic_chset<CharT>())
+{
+ ptr->set(
+ (std::numeric_limits<CharT>::min)(),
+ (std::numeric_limits<CharT>::max)()
+ );
+}
+
+template <typename CharT>
+inline chset<CharT>::chset(nothing_parser arg_)
+: ptr(new basic_chset<CharT>()) {}
+
+template <typename CharT>
+inline chset<CharT>::chset(chlit<CharT> const& arg_)
+: ptr(new basic_chset<CharT>())
+{ ptr->set(arg_.ch); }
+
+template <typename CharT>
+inline chset<CharT>::chset(range<CharT> const& arg_)
+: ptr(new basic_chset<CharT>())
+{ ptr->set(arg_.first, arg_.last); }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_)
+: ptr(new basic_chset<CharT>())
+{
+ set(arg_);
+}
+
+template <typename CharT>
+inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_)
+: ptr(new basic_chset<CharT>())
+{
+ set(arg_);
+}
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline chset<CharT>::~chset() {}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(chset const& rhs)
+{
+ ptr = rhs.ptr;
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(CharT rhs)
+{
+ utility::impl::detach_clear(ptr);
+ ptr->set(rhs);
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(anychar_parser rhs)
+{
+ utility::impl::detach_clear(ptr);
+ ptr->set(
+ (std::numeric_limits<CharT>::min)(),
+ (std::numeric_limits<CharT>::max)()
+ );
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(nothing_parser rhs)
+{
+ utility::impl::detach_clear(ptr);
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(chlit<CharT> const& rhs)
+{
+ utility::impl::detach_clear(ptr);
+ ptr->set(rhs.ch);
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(range<CharT> const& rhs)
+{
+ utility::impl::detach_clear(ptr);
+ ptr->set(rhs.first, rhs.last);
+ return *this;
+}
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs)
+{
+ utility::impl::detach_clear(ptr);
+ set(rhs);
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs)
+{
+ utility::impl::detach_clear(ptr);
+ set(rhs);
+ return *this;
+}
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline void
+chset<CharT>::set(range<CharT> const& arg_)
+{
+ utility::impl::detach(ptr);
+ ptr->set(arg_.first, arg_.last);
+}
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline void
+chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_)
+{
+ utility::impl::detach(ptr);
+
+ if(arg_.positive.ch != (std::numeric_limits<CharT>::min)()) {
+ ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.ch - 1);
+ }
+ if(arg_.positive.ch != (std::numeric_limits<CharT>::max)()) {
+ ptr->set(arg_.positive.ch + 1, (std::numeric_limits<CharT>::max)());
+ }
+}
+
+template <typename CharT>
+inline void
+chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_)
+{
+ utility::impl::detach(ptr);
+
+ if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
+ ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
+ }
+ if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
+ ptr->set(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
+ }
+}
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+template <typename CharT>
+inline void
+chset<CharT>::clear(range<CharT> const& arg_)
+{
+ utility::impl::detach(ptr);
+ ptr->clear(arg_.first, arg_.last);
+}
+
+template <typename CharT>
+inline void
+chset<CharT>::clear(negated_char_parser<range<CharT> > const& arg_)
+{
+ utility::impl::detach(ptr);
+
+ if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
+ ptr->clear((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
+ }
+ if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
+ ptr->clear(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
+ }
+}
+
+template <typename CharT>
+inline bool
+chset<CharT>::test(CharT ch) const
+{ return ptr->test(ch); }
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::inverse()
+{
+ utility::impl::detach(ptr);
+ ptr->inverse();
+ return *this;
+}
+
+template <typename CharT>
+inline void
+chset<CharT>::swap(chset& x)
+{ ptr.swap(x.ptr); }
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator|=(chset const& x)
+{
+ utility::impl::detach(ptr);
+ *ptr |= *x.ptr;
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator&=(chset const& x)
+{
+ utility::impl::detach(ptr);
+ *ptr &= *x.ptr;
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator-=(chset const& x)
+{
+ utility::impl::detach(ptr);
+ *ptr -= *x.ptr;
+ return *this;
+}
+
+template <typename CharT>
+inline chset<CharT>&
+chset<CharT>::operator^=(chset const& x)
+{
+ utility::impl::detach(ptr);
+ *ptr ^= *x.ptr;
+ return *this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace boost::spirit
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp
new file mode 100644
index 0000000..ace6501
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp
@@ -0,0 +1,107 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2001-2003 Daniel Nuffer
+ http://spirit.sourceforge.net/
+
+ Distributed under 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_BASIC_CHSET_HPP
+#define BOOST_SPIRIT_BASIC_CHSET_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <bitset>
+#include <climits>
+#include <boost/spirit/home/classic/utility/impl/chset/range_run.hpp>
+#include <boost/spirit/home/classic/namespace.hpp>
+
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+ ///////////////////////////////////////////////////////////////////////////
+ //
+ // basic_chset: basic character set implementation using range_run
+ //
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ class basic_chset
+ {
+ public:
+ basic_chset();
+ basic_chset(basic_chset const& arg_);
+
+ bool test(CharT v) const;
+ void set(CharT from, CharT to);
+ void set(CharT c);
+ void clear(CharT from, CharT to);
+ void clear(CharT c);
+ void clear();
+
+ void inverse();
+ void swap(basic_chset& x);
+
+ basic_chset& operator|=(basic_chset const& x);
+ basic_chset& operator&=(basic_chset const& x);
+ basic_chset& operator-=(basic_chset const& x);
+ basic_chset& operator^=(basic_chset const& x);
+
+ private: utility::impl::range_run<CharT> rr;
+ };
+
+ #if (CHAR_BIT == 8)
+
+ ///////////////////////////////////////////////////////////////////////////
+ //
+ // basic_chset: specializations for 8 bit chars using std::bitset
+ //
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ class basic_chset_8bit {
+
+ public:
+ basic_chset_8bit();
+ basic_chset_8bit(basic_chset_8bit const& arg_);
+
+ bool test(CharT v) const;
+ void set(CharT from, CharT to);
+ void set(CharT c);
+ void clear(CharT from, CharT to);
+ void clear(CharT c);
+ void clear();
+
+ void inverse();
+ void swap(basic_chset_8bit& x);
+
+ basic_chset_8bit& operator|=(basic_chset_8bit const& x);
+ basic_chset_8bit& operator&=(basic_chset_8bit const& x);
+ basic_chset_8bit& operator-=(basic_chset_8bit const& x);
+ basic_chset_8bit& operator^=(basic_chset_8bit const& x);
+
+ private: std::bitset<256> bset;
+ };
+
+ /////////////////////////////////
+ template <>
+ class basic_chset<char>
+ : public basic_chset_8bit<char> {};
+
+ /////////////////////////////////
+ template <>
+ class basic_chset<signed char>
+ : public basic_chset_8bit<signed char> {};
+
+ /////////////////////////////////
+ template <>
+ class basic_chset<unsigned char>
+ : public basic_chset_8bit<unsigned char> {};
+
+#endif
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#endif
+
+#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp>
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp
new file mode 100644
index 0000000..e7d9272
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp
@@ -0,0 +1,246 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2001-2003 Daniel Nuffer
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_BASIC_CHSET_IPP
+#define BOOST_SPIRIT_BASIC_CHSET_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <bitset>
+#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// basic_chset: character set implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>::basic_chset() {}
+
+//////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>::basic_chset(basic_chset const& arg_)
+: rr(arg_.rr) {}
+
+//////////////////////////////////
+template <typename CharT>
+inline bool
+basic_chset<CharT>::test(CharT v) const
+{ return rr.test(v); }
+
+//////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::set(CharT from, CharT to)
+{ rr.set(utility::impl::range<CharT>(from, to)); }
+
+//////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::set(CharT c)
+{ rr.set(utility::impl::range<CharT>(c, c)); }
+
+//////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::clear(CharT from, CharT to)
+{ rr.clear(utility::impl::range<CharT>(from, to)); }
+
+//////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::clear()
+{ rr.clear(); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::inverse()
+{
+ basic_chset inv;
+ inv.set(
+ (std::numeric_limits<CharT>::min)(),
+ (std::numeric_limits<CharT>::max)()
+ );
+ inv -= *this;
+ swap(inv);
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset<CharT>::swap(basic_chset& x)
+{ rr.swap(x.rr); }
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>&
+basic_chset<CharT>::operator|=(basic_chset<CharT> const& x)
+{
+ typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
+ for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
+ rr.set(*iter);
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>&
+basic_chset<CharT>::operator&=(basic_chset<CharT> const& x)
+{
+ basic_chset inv;
+ inv.set(
+ (std::numeric_limits<CharT>::min)(),
+ (std::numeric_limits<CharT>::max)()
+ );
+ inv -= x;
+ *this -= inv;
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>&
+basic_chset<CharT>::operator-=(basic_chset<CharT> const& x)
+{
+ typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
+ for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
+ rr.clear(*iter);
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset<CharT>&
+basic_chset<CharT>::operator^=(basic_chset<CharT> const& x)
+{
+ basic_chset bma = x;
+ bma -= *this;
+ *this -= x;
+ *this |= bma;
+ return *this;
+}
+
+#if (CHAR_BIT == 8)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// basic_chset: specializations for 8 bit chars using std::bitset
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>::basic_chset_8bit() {}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>::basic_chset_8bit(basic_chset_8bit const& arg_)
+: bset(arg_.bset) {}
+
+/////////////////////////////////
+template <typename CharT>
+inline bool
+basic_chset_8bit<CharT>::test(CharT v) const
+{ return bset.test((unsigned char)v); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::set(CharT from, CharT to)
+{
+ for (int i = from; i <= to; ++i)
+ bset.set((unsigned char)i);
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::set(CharT c)
+{ bset.set((unsigned char)c); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::clear(CharT from, CharT to)
+{
+ for (int i = from; i <= to; ++i)
+ bset.reset((unsigned char)i);
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::clear(CharT c)
+{ bset.reset((unsigned char)c); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::clear()
+{ bset.reset(); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::inverse()
+{ bset.flip(); }
+
+/////////////////////////////////
+template <typename CharT>
+inline void
+basic_chset_8bit<CharT>::swap(basic_chset_8bit& x)
+{ std::swap(bset, x.bset); }
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>&
+basic_chset_8bit<CharT>::operator|=(basic_chset_8bit const& x)
+{
+ bset |= x.bset;
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>&
+basic_chset_8bit<CharT>::operator&=(basic_chset_8bit const& x)
+{
+ bset &= x.bset;
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>&
+basic_chset_8bit<CharT>::operator-=(basic_chset_8bit const& x)
+{
+ bset &= ~x.bset;
+ return *this;
+}
+
+/////////////////////////////////
+template <typename CharT>
+inline basic_chset_8bit<CharT>&
+basic_chset_8bit<CharT>::operator^=(basic_chset_8bit const& x)
+{
+ bset ^= x.bset;
+ return *this;
+}
+
+#endif
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace boost::spirit
+
+#endif
+
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.hpp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.hpp
new file mode 100644
index 0000000..579bcae
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.hpp
@@ -0,0 +1,127 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Distributed under 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_RANGE_RUN_HPP
+#define BOOST_SPIRIT_RANGE_RUN_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <vector>
+
+#include <boost/spirit/home/classic/namespace.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+namespace utility { namespace impl {
+
+ ///////////////////////////////////////////////////////////////////////////
+ //
+ // range class
+ //
+ // Implements a closed range of values. This class is used in
+ // the implementation of the range_run class.
+ //
+ // { Low level implementation detail }
+ // { Not to be confused with BOOST_SPIRIT_CLASSIC_NS::range }
+ //
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ struct range {
+
+ range(CharT first, CharT last);
+
+ bool is_valid() const;
+ bool includes(CharT v) const;
+ bool includes(range const& r) const;
+ bool overlaps(range const& r) const;
+ void merge(range const& r);
+
+ CharT first;
+ CharT last;
+ };
+
+ //////////////////////////////////
+ template <typename CharT>
+ struct range_char_compare {
+
+ bool operator()(range<CharT> const& x, const CharT y) const
+ { return x.first < y; }
+
+ bool operator()(const CharT x, range<CharT> const& y) const
+ { return x < y.first; }
+
+ // This additional operator is required for the checked STL shipped
+ // with VC8 testing the ordering of the iterators passed to the
+ // std::lower_bound algo this range_char_compare<> predicate is passed
+ // to.
+ bool operator()(range<CharT> const& x, range<CharT> const& y) const
+ { return x.first < y.first; }
+ };
+
+ //////////////////////////////////
+ template <typename CharT>
+ struct range_compare {
+
+ bool operator()(range<CharT> const& x, range<CharT> const& y) const
+ { return x.first < y.first; }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ //
+ // range_run
+ //
+ // An implementation of a sparse bit (boolean) set. The set uses
+ // a sorted vector of disjoint ranges. This class implements the
+ // bare minimum essentials from which the full range of set
+ // operators can be implemented. The set is constructed from
+ // ranges. Internally, adjacent or overlapping ranges are
+ // coalesced.
+ //
+ // range_runs are very space-economical in situations where there
+ // are lots of ranges and a few individual disjoint values.
+ // Searching is O(log n) where n is the number of ranges.
+ //
+ // { Low level implementation detail }
+ //
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ class range_run {
+
+ public:
+
+ typedef range<CharT> range_t;
+ typedef std::vector<range_t> run_t;
+ typedef typename run_t::iterator iterator;
+ typedef typename run_t::const_iterator const_iterator;
+
+ void swap(range_run& rr);
+ bool test(CharT v) const;
+ void set(range_t const& r);
+ void clear(range_t const& r);
+ void clear();
+
+ const_iterator begin() const;
+ const_iterator end() const;
+
+ private:
+
+ void merge(iterator iter, range_t const& r);
+
+ run_t run;
+ };
+
+}}
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS::utility::impl
+
+#endif
+
+#include <boost/spirit/home/classic/utility/impl/chset/range_run.ipp>
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.ipp
new file mode 100644
index 0000000..ede1567
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset/range_run.ipp
@@ -0,0 +1,218 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_RANGE_RUN_IPP
+#define BOOST_SPIRIT_RANGE_RUN_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <algorithm> // for std::lower_bound
+#include <boost/spirit/home/classic/core/assert.hpp> // for BOOST_SPIRIT_ASSERT
+#include <boost/spirit/home/classic/utility/impl/chset/range_run.hpp>
+#include <boost/spirit/home/classic/debug.hpp>
+#include <boost/limits.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+ namespace utility { namespace impl {
+
+ ///////////////////////////////////////////////////////////////////////
+ //
+ // range class implementation
+ //
+ ///////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ inline range<CharT>::range(CharT first_, CharT last_)
+ : first(first_), last(last_) {}
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline bool
+ range<CharT>::is_valid() const
+ { return first <= last; }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline bool
+ range<CharT>::includes(range const& r) const
+ { return (first <= r.first) && (last >= r.last); }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline bool
+ range<CharT>::includes(CharT v) const
+ { return (first <= v) && (last >= v); }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline bool
+ range<CharT>::overlaps(range const& r) const
+ {
+ CharT decr_first =
+ first == (std::numeric_limits<CharT>::min)() ? first : first-1;
+ CharT incr_last =
+ last == (std::numeric_limits<CharT>::max)() ? last : last+1;
+
+ return (decr_first <= r.last) && (incr_last >= r.first);
+ }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline void
+ range<CharT>::merge(range const& r)
+ {
+ first = (std::min)(first, r.first);
+ last = (std::max)(last, r.last);
+ }
+
+ ///////////////////////////////////////////////////////////////////////
+ //
+ // range_run class implementation
+ //
+ ///////////////////////////////////////////////////////////////////////
+ template <typename CharT>
+ inline bool
+ range_run<CharT>::test(CharT v) const
+ {
+ if (!run.empty())
+ {
+ const_iterator iter =
+ std::lower_bound(
+ run.begin(), run.end(), v,
+ range_char_compare<CharT>()
+ );
+
+ if (iter != run.end() && iter->includes(v))
+ return true;
+ if (iter != run.begin())
+ return (--iter)->includes(v);
+ }
+ return false;
+ }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline void
+ range_run<CharT>::swap(range_run& rr)
+ { run.swap(rr.run); }
+
+ //////////////////////////////////
+ template <typename CharT>
+ void
+ range_run<CharT>::merge(iterator iter, range<CharT> const& r)
+ {
+ iter->merge(r);
+ iterator i = iter + 1;
+
+ while (i != run.end() && iter->overlaps(*i))
+ iter->merge(*i++);
+
+ run.erase(iter+1, i);
+ }
+
+ //////////////////////////////////
+ template <typename CharT>
+ void
+ range_run<CharT>::set(range<CharT> const& r)
+ {
+ BOOST_SPIRIT_ASSERT(r.is_valid());
+ if (!run.empty())
+ {
+ iterator iter =
+ std::lower_bound(
+ run.begin(), run.end(), r,
+ range_compare<CharT>()
+ );
+
+ if ((iter != run.end() && iter->includes(r)) ||
+ ((iter != run.begin()) && (iter - 1)->includes(r)))
+ return;
+
+ if (iter != run.begin() && (iter - 1)->overlaps(r))
+ merge(--iter, r);
+
+ else if (iter != run.end() && iter->overlaps(r))
+ merge(iter, r);
+
+ else
+ run.insert(iter, r);
+ }
+ else
+ {
+ run.push_back(r);
+ }
+ }
+
+ //////////////////////////////////
+ template <typename CharT>
+ void
+ range_run<CharT>::clear(range<CharT> const& r)
+ {
+ BOOST_SPIRIT_ASSERT(r.is_valid());
+ if (!run.empty())
+ {
+ iterator iter =
+ std::lower_bound(
+ run.begin(), run.end(), r,
+ range_compare<CharT>()
+ );
+
+ iterator left_iter;
+
+ if ((iter != run.begin()) &&
+ (left_iter = (iter - 1))->includes(r.first))
+ {
+ if (left_iter->last > r.last)
+ {
+ CharT save_last = left_iter->last;
+ left_iter->last = r.first-1;
+ run.insert(iter, range<CharT>(r.last+1, save_last));
+ return;
+ }
+ else
+ {
+ left_iter->last = r.first-1;
+ }
+ }
+
+ iterator i = iter;
+ while (i != run.end() && r.includes(*i))
+ i++;
+ if (i != run.end() && i->includes(r.last))
+ i->first = r.last+1;
+ run.erase(iter, i);
+ }
+ }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline void
+ range_run<CharT>::clear()
+ { run.clear(); }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline typename range_run<CharT>::const_iterator
+ range_run<CharT>::begin() const
+ { return run.begin(); }
+
+ //////////////////////////////////
+ template <typename CharT>
+ inline typename range_run<CharT>::const_iterator
+ range_run<CharT>::end() const
+ { return run.end(); }
+
+ }} // namespace utility::impl
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace boost::spirit
+
+#endif
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp
new file mode 100644
index 0000000..4319c9b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp
@@ -0,0 +1,666 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is 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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_CHSET_OPERATORS_IPP
+#define BOOST_SPIRIT_CHSET_OPERATORS_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/limits.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) |= b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) -= b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator~(chset<CharT> const& a)
+{
+ return chset<CharT>(a).inverse();
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) &= b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^= b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// range <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, range<CharT> const& b)
+{
+ chset<CharT> a_(a);
+ a_.set(b);
+ return a_;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, range<CharT> const& b)
+{
+ chset<CharT> a_(a);
+ if(b.first != (std::numeric_limits<CharT>::min)()) {
+ a_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), b.first - 1));
+ }
+ if(b.last != (std::numeric_limits<CharT>::max)()) {
+ a_.clear(range<CharT>(b.last + 1, (std::numeric_limits<CharT>::max)()));
+ }
+ return a_;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, range<CharT> const& b)
+{
+ chset<CharT> a_(a);
+ a_.clear(b);
+ return a_;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, range<CharT> const& b)
+{
+ return a ^ chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(range<CharT> const& a, chset<CharT> const& b)
+{
+ chset<CharT> b_(b);
+ b_.set(a);
+ return b_;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(range<CharT> const& a, chset<CharT> const& b)
+{
+ chset<CharT> b_(b);
+ if(a.first != (std::numeric_limits<CharT>::min)()) {
+ b_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), a.first - 1));
+ }
+ if(a.last != (std::numeric_limits<CharT>::max)()) {
+ b_.clear(range<CharT>(a.last + 1, (std::numeric_limits<CharT>::max)()));
+ }
+ return b_;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(range<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) - b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(range<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^ b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// literal primitives <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, CharT b)
+{
+ return a | chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, CharT b)
+{
+ return a & chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, CharT b)
+{
+ return a - chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, CharT b)
+{
+ return a ^ chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(CharT a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) | b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(CharT a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) & b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(CharT a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) - b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(CharT a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^ b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// chlit <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, chlit<CharT> const& b)
+{
+ return a | chset<CharT>(b.ch);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, chlit<CharT> const& b)
+{
+ return a & chset<CharT>(b.ch);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, chlit<CharT> const& b)
+{
+ return a - chset<CharT>(b.ch);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, chlit<CharT> const& b)
+{
+ return a ^ chset<CharT>(b.ch);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chlit<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a.ch) | b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chlit<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a.ch) & b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chlit<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a.ch) - b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chlit<CharT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a.ch) ^ b;
+}
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// negated_char_parser <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
+{
+ return a | chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
+{
+ return a & chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
+{
+ return a - chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, negated_char_parser<ParserT> const& b)
+{
+ return a ^ chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator|(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) | b;
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator&(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) & b;
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator-(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) - b;
+}
+
+//////////////////////////////////
+template <typename CharT, typename ParserT>
+inline chset<CharT>
+operator^(negated_char_parser<ParserT> const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^ b;
+}
+
+#else // BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// negated_char_parser<range> <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
+{
+ return a | chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
+{
+ return a & chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
+{
+ return a - chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
+{
+ return a ^ chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) | b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) & b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) - b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^ b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// negated_char_parser<chlit> <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
+{
+ return a | chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
+{
+ return a & chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
+{
+ return a - chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
+{
+ return a ^ chset<CharT>(b);
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) | b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) & b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) - b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
+{
+ return chset<CharT>(a) ^ b;
+}
+
+#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// anychar_parser <--> chset free operators
+//
+// Where a is chset and b is a anychar_parser, and vice-versa, implements:
+//
+// a | b, a & b, a - b, a ^ b
+//
+///////////////////////////////////////////////////////////////////////////////
+namespace impl {
+
+ template <typename CharT>
+ inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
+ full()
+ {
+ static BOOST_SPIRIT_CLASSIC_NS::range<CharT> full_(
+ (std::numeric_limits<CharT>::min)(),
+ (std::numeric_limits<CharT>::max)());
+ return full_;
+ }
+
+ template <typename CharT>
+ inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
+ empty()
+ {
+ static BOOST_SPIRIT_CLASSIC_NS::range<CharT> empty_;
+ return empty_;
+ }
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const&, anychar_parser)
+{
+ return chset<CharT>(impl::full<CharT>());
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& a, anychar_parser)
+{
+ return a;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const&, anychar_parser)
+{
+ return chset<CharT>();
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, anychar_parser)
+{
+ return ~a;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(anychar_parser, chset<CharT> const& /*b*/)
+{
+ return chset<CharT>(impl::full<CharT>());
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(anychar_parser, chset<CharT> const& b)
+{
+ return b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(anychar_parser, chset<CharT> const& b)
+{
+ return ~b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(anychar_parser, chset<CharT> const& b)
+{
+ return ~b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// nothing_parser <--> chset free operators implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(chset<CharT> const& a, nothing_parser)
+{
+ return a;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(chset<CharT> const& /*a*/, nothing_parser)
+{
+ return impl::empty<CharT>();
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(chset<CharT> const& a, nothing_parser)
+{
+ return a;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(chset<CharT> const& a, nothing_parser)
+{
+ return a;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator|(nothing_parser, chset<CharT> const& b)
+{
+ return b;
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator&(nothing_parser, chset<CharT> const& /*b*/)
+{
+ return impl::empty<CharT>();
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator-(nothing_parser, chset<CharT> const& /*b*/)
+{
+ return impl::empty<CharT>();
+}
+
+//////////////////////////////////
+template <typename CharT>
+inline chset<CharT>
+operator^(nothing_parser, chset<CharT> const& b)
+{
+ return b;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace boost::spirit
+
+#endif
+