Пример #1
0
void TheorySets::check(Effort e) {
  if (done() && !fullEffort(e)) {
    return;
  }
  TimerStat::CodeTimer checkTimer(d_checkTime);
  d_internal->check(e);
}
Пример #2
0
void TheoryFp::check(Effort level) {
  if (done() && !fullEffort(level)) {
    return;
  }

  while(!done()) {
    // Get all the assertions
    Assertion assertion = get();
    TNode fact = assertion.assertion;

    Debug("fp") << "TheoryFp::check(): processing " << fact << std::endl;

    // Do the work
    switch(fact.getKind()) {

    /* cases for all the theory's kinds go here... */

    default:
      Unhandled(fact.getKind());
    }
  }

}/* TheoryFp::check() */
Пример #3
0
void TheoryIdl::check(Effort level) {
    if (done() && !fullEffort(level)) {
        return;
    }

    TimerStat::CodeTimer checkTimer(d_checkTime);

    while(!done()) {

        // Get the next assertion
        Assertion assertion = get();
        Debug("theory::idl") << "TheoryIdl::check(): processing " << assertion.assertion << std::endl;

        // Convert the assertion into the internal representation
        IDLAssertion idlAssertion(assertion.assertion);
        Debug("theory::idl") << "TheoryIdl::check(): got " << idlAssertion << std::endl;

        if (idlAssertion.ok()) {
            if (idlAssertion.getOp() == kind::DISTINCT) {
                // We don't handle dis-equalities
                d_out->setIncomplete();
            } else {
                // Process the convex assertions immediately
                bool ok = processAssertion(idlAssertion);
                if (!ok) {
                    // In conflict, we're done
                    return;
                }
            }
        } else {
            // Not an IDL assertion, set incomplete
            d_out->setIncomplete();
        }
    }

}