FM / impl

/usr/include/boost/spirit/home/classic/utility/impl/

/usr/include/boost/spirit/home/classic/utility/impl

Name	Size	Mode	Actions
chset/	-	0755	rm
chset.ipp	7859	0644	edit dl rm
chset_operators.ipp	14373	0644	edit dl rm
confix.ipp	7756	0644	edit dl rm
escape_char.ipp	8995	0644	edit dl rm
lists.ipp	5736	0644	edit dl rm
regex.ipp	2580	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/classic/utility/impl/chset_operators.ipp (14373B)

/*=============================================================================
    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

/*============================================================================= 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 /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN /////////////////////////////////////////////////////////////////////////////// // // chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, chset const& b) { return chset(a) |= b; } ////////////////////////////////// template inline chset operator-(chset const& a, chset const& b) { return chset(a) -= b; } ////////////////////////////////// template inline chset operator~(chset const& a) { return chset(a).inverse(); } ////////////////////////////////// template inline chset operator&(chset const& a, chset const& b) { return chset(a) &= b; } ////////////////////////////////// template inline chset operator^(chset const& a, chset const& b) { return chset(a) ^= b; } /////////////////////////////////////////////////////////////////////////////// // // range <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, range const& b) { chset a_(a); a_.set(b); return a_; } ////////////////////////////////// template inline chset operator&(chset const& a, range const& b) { chset a_(a); if(b.first != (std::numeric_limits::min)()) { a_.clear(range((std::numeric_limits::min)(), b.first - 1)); } if(b.last != (std::numeric_limits::max)()) { a_.clear(range(b.last + 1, (std::numeric_limits::max)())); } return a_; } ////////////////////////////////// template inline chset operator-(chset const& a, range const& b) { chset a_(a); a_.clear(b); return a_; } ////////////////////////////////// template inline chset operator^(chset const& a, range const& b) { return a ^ chset(b); } ////////////////////////////////// template inline chset operator|(range const& a, chset const& b) { chset b_(b); b_.set(a); return b_; } ////////////////////////////////// template inline chset operator&(range const& a, chset const& b) { chset b_(b); if(a.first != (std::numeric_limits::min)()) { b_.clear(range((std::numeric_limits::min)(), a.first - 1)); } if(a.last != (std::numeric_limits::max)()) { b_.clear(range(a.last + 1, (std::numeric_limits::max)())); } return b_; } ////////////////////////////////// template inline chset operator-(range const& a, chset const& b) { return chset(a) - b; } ////////////////////////////////// template inline chset operator^(range const& a, chset const& b) { return chset(a) ^ b; } /////////////////////////////////////////////////////////////////////////////// // // literal primitives <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, CharT b) { return a | chset(b); } ////////////////////////////////// template inline chset operator&(chset const& a, CharT b) { return a & chset(b); } ////////////////////////////////// template inline chset operator-(chset const& a, CharT b) { return a - chset(b); } ////////////////////////////////// template inline chset operator^(chset const& a, CharT b) { return a ^ chset(b); } ////////////////////////////////// template inline chset operator|(CharT a, chset const& b) { return chset(a) | b; } ////////////////////////////////// template inline chset operator&(CharT a, chset const& b) { return chset(a) & b; } ////////////////////////////////// template inline chset operator-(CharT a, chset const& b) { return chset(a) - b; } ////////////////////////////////// template inline chset operator^(CharT a, chset const& b) { return chset(a) ^ b; } /////////////////////////////////////////////////////////////////////////////// // // chlit <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, chlit const& b) { return a | chset(b.ch); } ////////////////////////////////// template inline chset operator&(chset const& a, chlit const& b) { return a & chset(b.ch); } ////////////////////////////////// template inline chset operator-(chset const& a, chlit const& b) { return a - chset(b.ch); } ////////////////////////////////// template inline chset operator^(chset const& a, chlit const& b) { return a ^ chset(b.ch); } ////////////////////////////////// template inline chset operator|(chlit const& a, chset const& b) { return chset(a.ch) | b; } ////////////////////////////////// template inline chset operator&(chlit const& a, chset const& b) { return chset(a.ch) & b; } ////////////////////////////////// template inline chset operator-(chlit const& a, chset const& b) { return chset(a.ch) - b; } ////////////////////////////////// template inline chset operator^(chlit const& a, chset const& b) { return chset(a.ch) ^ b; } /////////////////////////////////////////////////////////////////////////////// // // negated_char_parser <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, negated_char_parser > const& b) { return a | chset(b); } ////////////////////////////////// template inline chset operator&(chset const& a, negated_char_parser > const& b) { return a & chset(b); } ////////////////////////////////// template inline chset operator-(chset const& a, negated_char_parser > const& b) { return a - chset(b); } ////////////////////////////////// template inline chset operator^(chset const& a, negated_char_parser > const& b) { return a ^ chset(b); } ////////////////////////////////// template inline chset operator|(negated_char_parser > const& a, chset const& b) { return chset(a) | b; } ////////////////////////////////// template inline chset operator&(negated_char_parser > const& a, chset const& b) { return chset(a) & b; } ////////////////////////////////// template inline chset operator-(negated_char_parser > const& a, chset const& b) { return chset(a) - b; } ////////////////////////////////// template inline chset operator^(negated_char_parser > const& a, chset const& b) { return chset(a) ^ b; } /////////////////////////////////////////////////////////////////////////////// // // negated_char_parser <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, negated_char_parser > const& b) { return a | chset(b); } ////////////////////////////////// template inline chset operator&(chset const& a, negated_char_parser > const& b) { return a & chset(b); } ////////////////////////////////// template inline chset operator-(chset const& a, negated_char_parser > const& b) { return a - chset(b); } ////////////////////////////////// template inline chset operator^(chset const& a, negated_char_parser > const& b) { return a ^ chset(b); } ////////////////////////////////// template inline chset operator|(negated_char_parser > const& a, chset const& b) { return chset(a) | b; } ////////////////////////////////// template inline chset operator&(negated_char_parser > const& a, chset const& b) { return chset(a) & b; } ////////////////////////////////// template inline chset operator-(negated_char_parser > const& a, chset const& b) { return chset(a) - b; } ////////////////////////////////// template inline chset operator^(negated_char_parser > const& a, chset const& b) { return chset(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 inline BOOST_SPIRIT_CLASSIC_NS::range const& full() { static BOOST_SPIRIT_CLASSIC_NS::range full_( (std::numeric_limits::min)(), (std::numeric_limits::max)()); return full_; } template inline BOOST_SPIRIT_CLASSIC_NS::range const& empty() { static BOOST_SPIRIT_CLASSIC_NS::range empty_; return empty_; } } ////////////////////////////////// template inline chset operator|(chset const&, anychar_parser) { return chset(impl::full()); } ////////////////////////////////// template inline chset operator&(chset const& a, anychar_parser) { return a; } ////////////////////////////////// template inline chset operator-(chset const&, anychar_parser) { return chset(); } ////////////////////////////////// template inline chset operator^(chset const& a, anychar_parser) { return ~a; } ////////////////////////////////// template inline chset operator|(anychar_parser, chset const& /*b*/) { return chset(impl::full()); } ////////////////////////////////// template inline chset operator&(anychar_parser, chset const& b) { return b; } ////////////////////////////////// template inline chset operator-(anychar_parser, chset const& b) { return ~b; } ////////////////////////////////// template inline chset operator^(anychar_parser, chset const& b) { return ~b; } /////////////////////////////////////////////////////////////////////////////// // // nothing_parser <--> chset free operators implementation // /////////////////////////////////////////////////////////////////////////////// template inline chset operator|(chset const& a, nothing_parser) { return a; } ////////////////////////////////// template inline chset operator&(chset const& /*a*/, nothing_parser) { return impl::empty(); } ////////////////////////////////// template inline chset operator-(chset const& a, nothing_parser) { return a; } ////////////////////////////////// template inline chset operator^(chset const& a, nothing_parser) { return a; } ////////////////////////////////// template inline chset operator|(nothing_parser, chset const& b) { return b; } ////////////////////////////////// template inline chset operator&(nothing_parser, chset const& /*b*/) { return impl::empty(); } ////////////////////////////////// template inline chset operator-(nothing_parser, chset const& /*b*/) { return impl::empty(); } ////////////////////////////////// template inline chset operator^(nothing_parser, chset const& b) { return b; } /////////////////////////////////////////////////////////////////////////////// BOOST_SPIRIT_CLASSIC_NAMESPACE_END }} // namespace boost::spirit #endif