/////////////////////////////////////////////////////////////////////////////// | |
// matchable.hpp | |
// | |
// Copyright 2008 Eric Niebler. 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_XPRESSIVE_DETAIL_DYNAMIC_MATCHABLE_HPP_EAN_10_04_2005 | |
#define BOOST_XPRESSIVE_DETAIL_DYNAMIC_MATCHABLE_HPP_EAN_10_04_2005 | |
// MS compatible compilers support #pragma once | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
#include <boost/assert.hpp> | |
#include <boost/mpl/assert.hpp> | |
#include <boost/intrusive_ptr.hpp> | |
#include <boost/throw_exception.hpp> | |
#include <boost/type_traits/is_same.hpp> | |
#include <boost/xpressive/detail/core/quant_style.hpp> | |
#include <boost/xpressive/detail/utility/counted_base.hpp> | |
#include <boost/xpressive/detail/detail_fwd.hpp> | |
#include <boost/xpressive/detail/dynamic/sequence.hpp> | |
#include <boost/xpressive/regex_error.hpp> | |
namespace boost { namespace xpressive { namespace detail | |
{ | |
////////////////////////////////////////////////////////////////////////// | |
// quant_spec | |
struct quant_spec | |
{ | |
unsigned int min_; | |
unsigned int max_; | |
bool greedy_; | |
std::size_t *hidden_mark_count_; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// matchable | |
template<typename BidiIter> | |
struct matchable | |
{ | |
typedef BidiIter iterator_type; | |
typedef typename iterator_value<iterator_type>::type char_type; | |
virtual ~matchable() {} | |
virtual bool match(match_state<BidiIter> &state) const = 0; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// matchable_ex | |
template<typename BidiIter> | |
struct matchable_ex | |
: matchable<BidiIter> | |
, counted_base<matchable_ex<BidiIter> > | |
{ | |
typedef BidiIter iterator_type; | |
typedef typename iterator_value<iterator_type>::type char_type; | |
virtual void link(xpression_linker<char_type> &) const | |
{ | |
} | |
virtual void peek(xpression_peeker<char_type> &peeker) const | |
{ | |
peeker.fail(); | |
} | |
virtual void repeat(quant_spec const &, sequence<BidiIter> &) const | |
{ | |
BOOST_THROW_EXCEPTION( | |
regex_error(regex_constants::error_badrepeat, "expression cannot be quantified") | |
); | |
} | |
/////////////////////////////////////////////////////////////////////////////////////////////// | |
// The following 4 functions (push_match, top_match, pop_match and skip_match) are | |
// used to implement looping and branching across the matchers. Call push_match to record | |
// a position. Then, another matcher further down the xpression chain has the | |
// option to call either top_match, pop_match or skip_match. top_match and pop_match will | |
// jump back to the place recorded by push_match, whereas skip_match will skip the jump and | |
// pass execution down the xpression chain. top_match will leave the xpression on top of the | |
// stack, whereas pop_match will remove it. Each function comes in 2 flavors: one for | |
// statically bound xpressions and one for dynamically bound xpressions. | |
// | |
template<typename Top> | |
bool push_match(match_state<BidiIter> &state) const | |
{ | |
BOOST_MPL_ASSERT((is_same<Top, matchable_ex<BidiIter> >)); | |
return this->match(state); | |
} | |
static bool top_match(match_state<BidiIter> &state, void const *top) | |
{ | |
return static_cast<matchable_ex<BidiIter> const *>(top)->match(state); | |
} | |
static bool pop_match(match_state<BidiIter> &state, void const *top) | |
{ | |
return static_cast<matchable_ex<BidiIter> const *>(top)->match(state); | |
} | |
bool skip_match(match_state<BidiIter> &state) const | |
{ | |
return this->match(state); | |
} | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
// shared_matchable | |
template<typename BidiIter> | |
struct shared_matchable | |
{ | |
typedef BidiIter iterator_type; | |
typedef typename iterator_value<BidiIter>::type char_type; | |
typedef intrusive_ptr<matchable_ex<BidiIter> const> matchable_ptr; | |
BOOST_STATIC_CONSTANT(std::size_t, width = unknown_width::value); | |
BOOST_STATIC_CONSTANT(bool, pure = false); | |
shared_matchable(matchable_ptr const &xpr = matchable_ptr()) | |
: xpr_(xpr) | |
{ | |
} | |
bool operator !() const | |
{ | |
return !this->xpr_; | |
} | |
friend bool operator ==(shared_matchable<BidiIter> const &left, shared_matchable<BidiIter> const &right) | |
{ | |
return left.xpr_ == right.xpr_; | |
} | |
friend bool operator !=(shared_matchable<BidiIter> const &left, shared_matchable<BidiIter> const &right) | |
{ | |
return left.xpr_ != right.xpr_; | |
} | |
matchable_ptr const &matchable() const | |
{ | |
return this->xpr_; | |
} | |
bool match(match_state<BidiIter> &state) const | |
{ | |
return this->xpr_->match(state); | |
} | |
void link(xpression_linker<char_type> &linker) const | |
{ | |
this->xpr_->link(linker); | |
} | |
void peek(xpression_peeker<char_type> &peeker) const | |
{ | |
this->xpr_->peek(peeker); | |
} | |
// BUGBUG yuk! | |
template<typename Top> | |
bool push_match(match_state<BidiIter> &state) const | |
{ | |
BOOST_MPL_ASSERT((is_same<Top, matchable_ex<BidiIter> >)); | |
return this->match(state); | |
} | |
private: | |
matchable_ptr xpr_; | |
}; | |
}}} // namespace boost::xpressive::detail | |
#endif |