diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/spirit/home/classic/utility')
8 files changed, 0 insertions, 2201 deletions
diff --git a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset.hpp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset.hpp deleted file mode 100644 index 36354564243..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset.hpp +++ /dev/null @@ -1,187 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset_operators.hpp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset_operators.hpp deleted file mode 100644 index d42b5faae48..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/chset_operators.hpp +++ /dev/null @@ -1,402 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset.ipp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset.ipp deleted file mode 100644 index 6e2130b222e..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset.ipp +++ /dev/null @@ -1,322 +0,0 @@ -/*============================================================================= - 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; - } - } - -}} // 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); } - -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_); -} - -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; -} - -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; -} - -template <typename CharT> -inline void -chset<CharT>::set(range<CharT> const& arg_) -{ - utility::impl::detach(ptr); - ptr->set(arg_.first, arg_.last); -} - -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)()); - } -} - -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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp deleted file mode 100644 index ace650166fe..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp +++ /dev/null @@ -1,107 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp deleted file mode 100644 index e7d92723454..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp +++ /dev/null @@ -1,246 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.hpp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.hpp deleted file mode 100644 index 579bcaec708..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.hpp +++ /dev/null @@ -1,127 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.ipp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.ipp deleted file mode 100644 index ede15673fca..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset/range_run.ipp +++ /dev/null @@ -1,218 +0,0 @@ -/*============================================================================= - 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/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset_operators.ipp b/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset_operators.ipp deleted file mode 100644 index 842a679d6db..00000000000 --- a/src/third_party/boost-1.56.0/boost/spirit/home/classic/utility/impl/chset_operators.ipp +++ /dev/null @@ -1,592 +0,0 @@ -/*============================================================================= - 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; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// 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; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// 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 - |