bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.eos())
{
return false;
}
char_type ch = *state.cur_;
if(traits_cast<Traits>(state).isctype(ch, this->newline_))
{
++state.cur_;
if(this->cr_ == ch && !state.eos() && this->nl_ == *state.cur_)
{
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
}
else if(next.match(state))
{
return true;
}
--state.cur_;
}
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::false_) const
{
typedef typename iterator_difference<BidiIter>::type difference_type;
BidiIter const tmp = state.cur_;
if(!detail::advance_to(state.cur_, -static_cast<difference_type>(this->width_), state.begin_))
{
state.cur_ = tmp;
return this->not_ ? next.match(state) : false;
}
// matching xpr could produce side-effects, save state
memento<BidiIter> mem = save_sub_matches(state);
if(this->not_)
{
// negative look-ahead assertions do not trigger partial matches.
save_restore<bool> partial_match(state.found_partial_match_);
detail::ignore_unused(partial_match);
if(this->xpr_.match(state))
{
restore_action_queue(mem, state);
restore_sub_matches(mem, state);
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
state.cur_ = tmp;
restore_action_queue(mem, state);
if(next.match(state))
{
reclaim_sub_matches(mem, state, true);
return true;
}
reclaim_sub_matches(mem, state, false);
}
else
{
if(!this->xpr_.match(state))
{
state.cur_ = tmp;
restore_action_queue(mem, state);
reclaim_sub_matches(mem, state, false);
return false;
}
BOOST_ASSERT(state.cur_ == tmp);
restore_action_queue(mem, state);
if(next.match(state))
{
reclaim_sub_matches(mem, state, true);
return true;
}
restore_sub_matches(mem, state);
}
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::false_) const
{
BidiIter const tmp = state.cur_;
// matching xpr could produce side-effects, save state
memento<BidiIter> mem = save_sub_matches(state);
if(this->not_)
{
// negative look-ahead assertions do not trigger partial matches.
save_restore<bool> partial_match(state.found_partial_match_);
detail::ignore_unused(partial_match);
if(this->xpr_.match(state))
{
restore_action_queue(mem, state);
restore_sub_matches(mem, state);
state.cur_ = tmp;
return false;
}
restore_action_queue(mem, state);
if(next.match(state))
{
reclaim_sub_matches(mem, state, true);
return true;
}
reclaim_sub_matches(mem, state, false);
}
else
{
if(!this->xpr_.match(state))
{
restore_action_queue(mem, state);
reclaim_sub_matches(mem, state, false);
return false;
}
state.cur_ = tmp;
restore_action_queue(mem, state);
if(next.match(state))
{
reclaim_sub_matches(mem, state, true);
return true;
}
restore_sub_matches(mem, state);
}
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
BOOST_ASSERT(this->mark_number_ < static_cast<int>(state.mark_count_));
sub_match_impl<BidiIter> const &br = state.sub_match(this->mark_number_);
if(!br.matched)
{
return false;
}
BidiIter const tmp = state.cur_;
for(BidiIter begin = br.first, end = br.second; begin != end; ++begin, ++state.cur_)
{
if(state.eos()
|| detail::translate(*state.cur_, traits_cast<Traits>(state), icase_type())
!= detail::translate(*begin, traits_cast<Traits>(state), icase_type()))
{
state.cur_ = tmp;
return false;
}
}
if(next.match(state))
{
return true;
}
state.cur_ = tmp;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, non_greedy_tag) const
{
BOOST_ASSERT(!this->leading_);
BidiIter const tmp = state.cur_;
unsigned int matches = 0;
for(; matches < this->min_; ++matches)
{
if(!this->xpr_.match(state))
{
state.cur_ = tmp;
return false;
}
}
do
{
if(next.match(state))
{
return true;
}
}
while(matches++ < this->max_ && this->xpr_.match(state));
state.cur_ = tmp;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.bos())
{
if(!state.flags_.match_bol_)
{
return false;
}
}
else
{
char_type ch = *boost::prior(state.cur_);
// If the previous character is not a newline, we're not at the start of a line
if(!traits_cast<Traits>(state).isctype(ch, this->newline_))
{
return false;
}
// There is no line-break between \r and \n
else if(ch == this->cr_ && !state.eos() && *state.cur_ == this->nl_)
{
return false;
}
}
return next.match(state);
}
static void search( Field &field, Next &next, int level, int lim ){
const Tumo TUMO = next.get(level);
const int LOOP = (TUMO.first==TUMO.second) ? 11 : 22; // 同色なら半分
for( int i=0; i<LOOP; ++i ){
// 1手置いた新しいフィールドの作成
Field new_field = field;
const Plan PLAN = getPlan(i);
if( setTumo( new_field, TUMO, PLAN ) == -1 ) continue;
// 初手をメモる
if( level==0 ) plan_first = PLAN;
// 発火する
InfoFire info;
fireField( new_field, info );
// 窒息確認
if( new_field.get(3,12)!=BRANK ) continue;
// フィールドを評価して過去最高ならメモ
int score = eval_field( new_field, next ); // フィールド形の評価
if( score>max_score ){
max_score = score;
plan_best = plan_first;
}
// さらなる深みへ
if( level<lim ) search( new_field, next, level+1, lim );
}
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
BidiIter cur = state.cur_;
bool const thisword = !state.eos() && this->is_word(traits_cast<Traits>(state), *cur);
bool const prevword = (!state.bos() || state.flags_.match_prev_avail_)
&& this->is_word(traits_cast<Traits>(state), *--cur);
return Cond::eval(prevword, thisword, state) && next.match(state);
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::true_) const
{
sub_match_impl<BidiIter> &br = state.sub_match(this->mark_number_);
if(this->max_ > br.repeat_count_)
{
++br.repeat_count_;
// loop back to the expression "pushed" in repeat_begin_matcher::match
if(next.top_match(state, this->back_))
{
return true;
}
else if(--br.repeat_count_ < this->min_)
{
return false;
}
}
// looping finished, continue matching the rest of the pattern
return next.skip_match(state);
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::true_) const
{
typedef typename iterator_difference<BidiIter>::type difference_type;
BidiIter const tmp = state.cur_;
if(!detail::advance_to(state.cur_, -static_cast<difference_type>(this->width_), state.begin_))
{
state.cur_ = tmp;
return this->not_ ? next.match(state) : false;
}
if(this->not_)
{
if(this->xpr_.match(state))
{
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
state.cur_ = tmp;
if(next.match(state))
{
return true;
}
}
else
{
if(!this->xpr_.match(state))
{
state.cur_ = tmp;
return false;
}
BOOST_ASSERT(state.cur_ == tmp);
if(next.match(state))
{
return true;
}
}
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
static bool match(match_state<BidiIter> &state, Next const &next)
{
attr_context old_attr_context = state.attr_context_;
state.attr_context_ = *old_attr_context.prev_attr_context_;
if(next.match(state))
{
return true;
}
state.attr_context_ = old_attr_context;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.eos() || this->not_ == this->in_set(traits_cast<Traits>(state), *state.cur_))
{
return false;
}
if(++state.cur_, next.match(state))
{
return true;
}
return --state.cur_, false;
}
bool match(state_type<BidiIter> &state, Next const &next) const
{
sub_match_impl<BidiIter> &br = state.sub_match(this->mark_number_);
BidiIter old_begin = br.begin_;
br.begin_ = state.cur_;
if(next.match(state))
{
return true;
}
br.begin_ = old_begin;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::true_) const
{
BidiIter const tmp = state.cur_;
if(this->not_)
{
// negative look-ahead assertions do not trigger partial matches.
save_restore<bool> partial_match(state.found_partial_match_);
detail::ignore_unused(partial_match);
if(this->xpr_.match(state))
{
state.cur_ = tmp;
return false;
}
else if(next.match(state))
{
return true;
}
}
else
{
if(!this->xpr_.match(state))
{
return false;
}
state.cur_ = tmp;
if(next.match(state))
{
return true;
}
}
BOOST_ASSERT(state.cur_ == tmp);
return false;
}
inline bool match_next(match_state<BidiIter> &state, Next const &next, int mark_number)
{
sub_match_impl<BidiIter> &br = state.sub_match(mark_number);
bool old_matched = br.matched;
br.matched = false;
if(next.match(state))
{
return true;
}
br.matched = old_matched;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::false_) const
{
sub_match_impl<BidiIter> &br = state.sub_match(this->mark_number_);
if(this->min_ <= br.repeat_count_)
{
if(next.skip_match(state))
{
return true;
}
}
if(this->max_ > br.repeat_count_)
{
++br.repeat_count_;
if(next.top_match(state, this->back_))
{
return true;
}
--br.repeat_count_;
}
return false;
}
bool match(state_type<BidiIter> &state, Next const &next) const
{
if(state.eos() || !this->charset_.test(*state.cur_, traits_cast<Traits>(state), icase_type()))
{
return false;
}
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
return false;
}
static bool match(state_type<BidiIter> &state, Next const &next)
{
if(state.eos())
{
return false;
}
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.eos() || this->not_ == traits_cast<Traits>(state).isctype(
*state.cur_, this->mask_))
{
return false;
}
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.eos() || this->not_ ==
this->in_range(traits_cast<Traits>(state), *state.cur_, icase_type()))
{
return false;
}
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
if(state.eos() || Not::value ==
(detail::translate(*state.cur_, traits_cast<Traits>(state), icase_type()) == this->ch_))
{
return false;
}
++state.cur_;
if(next.match(state))
{
return true;
}
--state.cur_;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
BidiIter tmp = state.cur_;
char_translate<Traits, ICase::value> trans(traits_cast<Traits>(state));
result_type const &result = this->sym_(state.cur_, state.end_, trans);
if(result)
{
void const *old_slot = state.attr_context_.attr_slots_[this->slot_];
state.attr_context_.attr_slots_[this->slot_] = &*result;
if(next.match(state))
{
return true;
}
state.attr_context_.attr_slots_[this->slot_] = old_slot;
}
state.cur_ = tmp;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, greedy_slow_tag) const
{
int const diff = -static_cast<int>(Xpr::width == unknown_width::value ? this->width_ : Xpr::width);
unsigned int matches = 0;
BidiIter const tmp = state.cur_;
// greedily match as much as we can
while(matches < this->max_ && this->xpr_.match(state))
{
++matches;
}
// If this repeater is at the front of the pattern, note
// how much of the input we consumed so that a repeated search
// doesn't have to cover the same ground again.
if(this->leading_)
{
state.next_search_ = (matches && matches < this->max_)
? state.cur_
: (tmp == state.end_) ? tmp : boost::next(tmp);
}
if(this->min_ > matches)
{
state.cur_ = tmp;
return false;
}
// try matching the rest of the pattern, and back off if necessary
for(; ; --matches, std::advance(state.cur_, diff))
{
if(next.match(state))
{
return true;
}
else if(this->min_ == matches)
{
state.cur_ = tmp;
return false;
}
}
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
// prevent repeated zero-width sub-matches from causing infinite recursion
sub_match_impl<BidiIter> &br = state.sub_match(this->mark_number_);
if(br.zero_width_ && br.begin_ == state.cur_)
{
return next.skip_match(state);
}
bool old_zero_width = br.zero_width_;
br.zero_width_ = (br.begin_ == state.cur_);
if(this->match_(state, next, greedy_type()))
{
return true;
}
br.zero_width_ = old_zero_width;
return false;
}
bool match(match_state<BidiIter> &state, Next const &next) const
{
BidiIter const tmp = state.cur_;
char_type const *begin = detail::data_begin(this->str_);
for(; begin != this->end_; ++begin, ++state.cur_)
{
if(state.eos() ||
(detail::translate(*state.cur_, traits_cast<Traits>(state), icase_type()) != *begin))
{
state.cur_ = tmp;
return false;
}
}
if(next.match(state))
{
return true;
}
state.cur_ = tmp;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, greedy_fast_tag) const
{
BidiIter const tmp = state.cur_;
std::size_t const diff_to_end = static_cast<std::size_t>(state.end_ - tmp);
// is there enough room?
if(this->min_ > diff_to_end)
{
if(this->leading_)
{
state.next_search_ = (tmp == state.end_) ? tmp : boost::next(tmp);
}
return false;
}
BidiIter const min_iter = tmp + this->min_;
state.cur_ += (std::min)((std::size_t)this->max_, diff_to_end);
if(this->leading_)
{
state.next_search_ = (diff_to_end && diff_to_end < this->max_)
? state.cur_
: (tmp == state.end_) ? tmp : boost::next(tmp);
}
for(;; --state.cur_)
{
if(next.match(state))
{
return true;
}
else if(min_iter == state.cur_)
{
state.cur_ = tmp;
return false;
}
}
}
bool match(state_type<BidiIter> &state, Next const &next) const
{
sub_match_impl<BidiIter> &br = state.sub_match(this->mark_number_);
BidiIter old_first = br.first;
BidiIter old_second = br.second;
bool old_matched = br.matched;
br.first = br.begin_;
br.second = state.cur_;
br.matched = true;
if(next.match(state))
{
return true;
}
br.first = old_first;
br.second = old_second;
br.matched = old_matched;
return false;
}
bool match_(match_state<BidiIter> &state, Next const &next, mpl::false_) const // Non-greedy
{
return next.match(state)
|| this->xpr_.BOOST_NESTED_TEMPLATE push_match<Next>(state);
}
static bool match(state_type<BidiIter> &state, Next const &next)
{
return state.eos() && next.match(state);
}
static type apply(null_type null, const Next& next) {
return type(next.get_head(), chain_type::apply(next.get_tail(), null));
}