コード例 #1
0
ファイル: Z3Solver.cpp プロジェクト: AmesianX/chef
z3::check_result Z3StackSolverImpl::check(const Query &query) {
    errs() << "====> Query size: " << query.constraints.size() << '\n';

    ConditionNodeList *cur_constraints = new ConditionNodeList();

    for (ConditionNodeRef node = query.constraints.head(),
            root = query.constraints.root();
            node != root; node = node->parent()) {
        // TODO: Handle special case of fast-forward
        cur_constraints->push_front(node);
    }

    ConditionNodeList::iterator cur_it, last_it;
    cur_it = cur_constraints->begin();
    last_it = last_constraints_->begin();

    while (cur_it != cur_constraints->end() &&
            last_it != last_constraints_->end() &&
            *cur_it == *last_it) {
        cur_it++;
        last_it++;
    }

    if (last_it != last_constraints_->end()) {
        unsigned amount = 1 + last_constraints_->back()->depth()
                - (*last_it)->depth();
        errs() << "====> POP x" << amount << '\n';
        pop(amount);
    }

    if (cur_it != cur_constraints->end()) {
        errs() << "====> PUSH x"
                << (cur_constraints->back()->depth() - (*cur_it)->depth() + 1)
                << '\n';

        while (cur_it != cur_constraints->end()) {
            push();
            solver_.add(builder_->construct((*cur_it)->expr()));
            cur_it++;
        }
    }

    last_constraints_.reset(cur_constraints);

    push();

    // Note the negation, since we're checking for validity
    // (i.e., a counterexample)
    solver_.add(!builder_->construct(query.expr));

    return solver_.check();
}
コード例 #2
0
 virtual bool Consume(RegExpInput* input_string,
                      bool anchor_at_start,
                      string* matched_string1,
                      string* matched_string2,
                      string* matched_string3) const {
   DCHECK(input_string);
   if (!utf8_regexp_.get()) {
     return false;
   }
   IcuRegExpInput* const input = static_cast<IcuRegExpInput*>(input_string);
   UErrorCode status = U_ZERO_ERROR;
   const scoped_ptr<RegexMatcher> matcher(
       utf8_regexp_->matcher(*input->Data(), status));
   bool match_succeeded = anchor_at_start
       ? matcher->lookingAt(input->position(), status)
       : matcher->find(input->position(), status);
   if (!match_succeeded || U_FAILURE(status)) {
     return false;
   }
   string* const matched_strings[] = {
     matched_string1, matched_string2, matched_string3
   };
   // If less matches than expected - fail.
   for (size_t i = 0; i < arraysize(matched_strings); ++i) {
     if (matched_strings[i]) {
       // Groups are counted from 1 rather than 0.
       const int group_index = i + 1;
       if (group_index > matcher->groupCount()) {
         return false;
       }
       *matched_strings[i] =
           UnicodeStringToUtf8String(matcher->group(group_index, status));
     }
   }
   input->set_position(matcher->end(status));
   return !U_FAILURE(status);
 }