diff --git a/Api/FormulaBuilder.cpp b/Api/FormulaBuilder.cpp index 94b2aff22..56694647f 100644 --- a/Api/FormulaBuilder.cpp +++ b/Api/FormulaBuilder.cpp @@ -54,8 +54,6 @@ namespace Api FormulaBuilder::FormulaBuilder(bool checkNames, bool checkBindingBoundVariables, bool allowImplicitlyTypedVariables, bool outputDummyNames) { - CALL("FormulaBuilder::FormulaBuilder"); - _aux->_checkNames=checkNames; _aux->_checkBindingBoundVariables=checkBindingBoundVariables; _aux->_allowImplicitlyTypedVariables=allowImplicitlyTypedVariables; @@ -64,66 +62,48 @@ FormulaBuilder::FormulaBuilder(bool checkNames, bool checkBindingBoundVariables, Sort FormulaBuilder::sort(const vstring& sortName) { - CALL("FormulaBuilder::sort"); - unsigned res = env.sorts->addSort(sortName); return Sort(res); } Sort FormulaBuilder::integerSort() { - CALL("FormulaBuilder::integerSort"); - return Sort(Sorts::SRT_INTEGER); } Sort FormulaBuilder::rationalSort() { - CALL("FormulaBuilder::integerSort"); - return Sort(Sorts::SRT_RATIONAL); } Sort FormulaBuilder::realSort() { - CALL("FormulaBuilder::integerSort"); - return Sort(Sorts::SRT_REAL); } Sort FormulaBuilder::defaultSort() { - CALL("FormulaBuilder::defaultSort"); - return Sort(Sorts::SRT_DEFAULT); } vstring FormulaBuilder::getSortName(Sort s) { - CALL("FormulaBuilder::getSortName"); - return env.sorts->sortName(s); } vstring FormulaBuilder::getPredicateName(Predicate p) { - CALL("FormulaBuilder::getPredicateName"); - return _aux->getSymbolName(true, p); } vstring FormulaBuilder::getFunctionName(Function f) { - CALL("FormulaBuilder::getFunctionName"); - return _aux->getSymbolName(true, f); } vstring FormulaBuilder::getVariableName(Var v) { - CALL("FormulaBuilder::getVariableName"); - return _aux->getVarName(v); } @@ -131,8 +111,6 @@ vstring FormulaBuilder::getVariableName(Var v) Var FormulaBuilder::var(const vstring& varName) { - CALL("FormulaBuilder::var"); - if(!_aux->_allowImplicitlyTypedVariables) { throw FormulaBuilderException("Creating implicitly typed variables is not allowed. Use function " "FormulaBuilder::var(const vstring& varName, Sort varSort) instead of " @@ -144,15 +122,11 @@ Var FormulaBuilder::var(const vstring& varName) Var FormulaBuilder::var(const vstring& varName, Sort varSort) { - CALL("FormulaBuilder::var"); - return _aux->getVar(varName, varSort); } Function FormulaBuilder::function(const vstring& funName,unsigned arity, bool builtIn) { - CALL("FormulaBuilder::function/2"); - static DArray domainSorts; domainSorts.init(arity, defaultSort()); return function(funName, arity, defaultSort(), domainSorts.array(), builtIn); @@ -160,8 +134,6 @@ Function FormulaBuilder::function(const vstring& funName,unsigned arity, bool bu Function FormulaBuilder::function(const vstring& funName, unsigned arity, Sort rangeSort, Sort* domainSorts, bool builtIn) { - CALL("FormulaBuilder::function/4"); - if(_aux->_checkNames) { if(!islower(funName[0]) && (funName.substr(0,2)!="$$")) { throw InvalidTPTPNameException("Function name must start with a lowercase character or \"$$\"", funName); @@ -196,16 +168,12 @@ Function FormulaBuilder::function(const vstring& funName, unsigned arity, Sort r Function FormulaBuilder::integerConstant(int i) { - CALL("FormulaBuilder::integerConstant"); - unsigned fun = env.signature->addIntegerConstant(IntegerConstantType(i)); return Function(fun); } Function FormulaBuilder::integerConstant(vstring i) { - CALL("FormulaBuilder::integerConstant"); - unsigned fun; try { fun = env.signature->addIntegerConstant(IntegerConstantType(i)); @@ -219,8 +187,6 @@ Function FormulaBuilder::integerConstant(vstring i) Predicate FormulaBuilder::predicate(const vstring& predName,unsigned arity, bool builtIn) { - CALL("FormulaBuilder::predicate/2"); - static DArray domainSorts; domainSorts.init(arity, defaultSort()); return predicate(predName, arity, domainSorts.array(), builtIn); @@ -228,8 +194,6 @@ Predicate FormulaBuilder::predicate(const vstring& predName,unsigned arity, bool Predicate FormulaBuilder::predicate(const vstring& predName, unsigned arity, Sort* domainSorts, bool builtIn) { - CALL("FormulaBuilder::predicate/3"); - if(_aux->_checkNames) { if(!islower(predName[0]) && (predName.substr(0,2)!="$$")) { throw InvalidTPTPNameException("Predicate name must start with a lowercase character or \"$$\"", predName); @@ -264,8 +228,6 @@ Predicate FormulaBuilder::predicate(const vstring& predName, unsigned arity, Sor Predicate FormulaBuilder::interpretedPredicate(InterpretedPredicate symbol) { - CALL("FormulaBuilder::interpretedPredicate"); - Interpretation itp; switch(symbol) { @@ -290,22 +252,16 @@ Predicate FormulaBuilder::interpretedPredicate(InterpretedPredicate symbol) void FormulaBuilder::addAttribute(Sort p, vstring name, vstring value) { - CALL("FormulaBuilder::addAttribute(Sort,vstring,vstring)"); - FBHelperCore::addAttribute(_aux->getSortAttributes(p), name, value); } unsigned FormulaBuilder::attributeCount(Sort p) { - CALL("FormulaBuilder::attributeCount(Sort)"); - return _aux->getSortAttributes(p).size(); } vstring FormulaBuilder::getAttributeName(Sort p, unsigned index) { - CALL("FormulaBuilder::getAttributeName(Sort,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -314,8 +270,6 @@ vstring FormulaBuilder::getAttributeName(Sort p, unsigned index) vstring FormulaBuilder::getAttributeValue(Sort p, unsigned index) { - CALL("FormulaBuilder::getAttributeValue(Sort,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -324,8 +278,6 @@ vstring FormulaBuilder::getAttributeValue(Sort p, unsigned index) vstring FormulaBuilder::getAttributeValue(Sort p, vstring attributeName) { - CALL("FormulaBuilder::getAttributeValue(Sort,vstring)"); - FBHelperCore::AttribStack::BottomFirstIterator it(_aux->getSortAttributes(p)); while(it.hasNext()) { pair curr = it.next(); @@ -338,22 +290,16 @@ vstring FormulaBuilder::getAttributeValue(Sort p, vstring attributeName) void FormulaBuilder::addAttribute(Predicate p, vstring name, vstring value) { - CALL("FormulaBuilder::addAttribute(Predicate,vstring,vstring)"); - FBHelperCore::addAttribute(_aux->getPredicateAttributes(p), name, value); } unsigned FormulaBuilder::attributeCount(Predicate p) { - CALL("FormulaBuilder::attributeCount(Predicate)"); - return _aux->getPredicateAttributes(p).size(); } vstring FormulaBuilder::getAttributeName(Predicate p, unsigned index) { - CALL("FormulaBuilder::getAttributeName(Predicate,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -362,8 +308,6 @@ vstring FormulaBuilder::getAttributeName(Predicate p, unsigned index) vstring FormulaBuilder::getAttributeValue(Predicate p, unsigned index) { - CALL("FormulaBuilder::getAttributeValue(Predicate,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -372,8 +316,6 @@ vstring FormulaBuilder::getAttributeValue(Predicate p, unsigned index) vstring FormulaBuilder::getAttributeValue(Predicate p, vstring attributeName) { - CALL("FormulaBuilder::getAttributeValue(Predicate,vstring)"); - FBHelperCore::AttribStack::BottomFirstIterator it(_aux->getPredicateAttributes(p)); while(it.hasNext()) { pair curr = it.next(); @@ -386,22 +328,16 @@ vstring FormulaBuilder::getAttributeValue(Predicate p, vstring attributeName) void FormulaBuilder::addAttribute(Function p, vstring name, vstring value) { - CALL("FormulaBuilder::addAttribute(Function,vstring,vstring)"); - FBHelperCore::addAttribute(_aux->getFunctionAttributes(p), name, value); } unsigned FormulaBuilder::attributeCount(Function p) { - CALL("FormulaBuilder::attributeCount(Function)"); - return _aux->getFunctionAttributes(p).size(); } vstring FormulaBuilder::getAttributeName(Function p, unsigned index) { - CALL("FormulaBuilder::getAttributeName(Function,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -410,8 +346,6 @@ vstring FormulaBuilder::getAttributeName(Function p, unsigned index) vstring FormulaBuilder::getAttributeValue(Function p, unsigned index) { - CALL("FormulaBuilder::getAttributeValue(Function,unsigned)"); - if(index>attributeCount(p)) { throw FormulaBuilderException("Attribute index out of bounds"); } @@ -420,8 +354,6 @@ vstring FormulaBuilder::getAttributeValue(Function p, unsigned index) vstring FormulaBuilder::getAttributeValue(Function p, vstring attributeName) { - CALL("FormulaBuilder::getAttributeValue(Function,vstring)"); - FBHelperCore::AttribStack::BottomFirstIterator it(_aux->getFunctionAttributes(p)); while(it.hasNext()) { pair curr = it.next(); @@ -435,8 +367,6 @@ vstring FormulaBuilder::getAttributeValue(Function p, vstring attributeName) Term FormulaBuilder::varTerm(const Var& v) { - CALL("FormulaBuilder::varTerm"); - Term res(Kernel::TermList(v,false)); res._aux=_aux; //assign the correct helper object return res; @@ -444,22 +374,16 @@ Term FormulaBuilder::varTerm(const Var& v) Term FormulaBuilder::term(const Function& f,const Term* args) { - CALL("FormulaBuilder::term"); - return _aux->term(f,args,env.signature->functionArity(f)); } Formula FormulaBuilder::atom(const Predicate& p, const Term* args, bool positive) { - CALL("FormulaBuilder::atom"); - return _aux->atom(p,positive, args,env.signature->predicateArity(p)); } Formula FormulaBuilder::equality(const Term& lhs,const Term& rhs, Sort sort, bool positive) { - CALL("FormulaBuilder::equality/4"); - if(lhs.sort()!=sort) { throw SortMismatchException("Sorts of equality sides is not as declared"); } @@ -468,8 +392,6 @@ Formula FormulaBuilder::equality(const Term& lhs,const Term& rhs, Sort sort, boo Formula FormulaBuilder::equality(const Term& lhs,const Term& rhs, bool positive) { - CALL("FormulaBuilder::equality/3"); - _aux->ensureEqualityArgumentsSortsMatch(lhs, rhs); unsigned srt = lhs.sort(); if(srt!=rhs.sort()) { @@ -483,8 +405,6 @@ Formula FormulaBuilder::equality(const Term& lhs,const Term& rhs, bool positive) Formula FormulaBuilder::trueFormula() { - CALL("FormulaBuilder::trueFormula"); - Formula res(new Kernel::Formula(true)); res._aux=_aux; //assign the correct helper object return res; @@ -492,8 +412,6 @@ Formula FormulaBuilder::trueFormula() Formula FormulaBuilder::falseFormula() { - CALL("FormulaBuilder::falseFormula"); - Formula res(new Kernel::Formula(false)); res._aux=_aux; //assign the correct helper object return res; @@ -501,8 +419,6 @@ Formula FormulaBuilder::falseFormula() Formula FormulaBuilder::negation(const Formula& f) { - CALL("FormulaBuilder::negation"); - if(f._aux!=_aux) { throw FormulaBuilderException("negation function called on a Formula object not built by the same FormulaBuilder object"); } @@ -514,8 +430,6 @@ Formula FormulaBuilder::negation(const Formula& f) Formula FormulaBuilder::formula(Connective c,const Formula& f1,const Formula& f2) { - CALL("FormulaBuilder::formula(Connective,const Formula&,const Formula&)"); - if(f1._aux!=_aux || f2._aux!=_aux) { throw FormulaBuilderException("formula function called on a Formula object not built by the same FormulaBuilder object"); } @@ -568,8 +482,6 @@ Formula FormulaBuilder::formula(Connective c,const Formula& f1,const Formula& f2 Formula FormulaBuilder::formula(Connective q,const Var& v,const Formula& f) { - CALL("FormulaBuilder::formula(Connective,const Var&,const Formula&)"); - if(f._aux!=_aux) { throw FormulaBuilderException("formula function called on a Formula object not built by the same FormulaBuilder object"); } @@ -605,8 +517,6 @@ Formula FormulaBuilder::formula(Connective q,const Var& v,const Formula& f) AnnotatedFormula FormulaBuilder::annotatedFormula(Formula f, Annotation a, vstring name) { - CALL("FormulaBuilder::annotatedFormula"); - if(f._aux!=_aux) { throw FormulaBuilderException("annotatedFormula function called on a Formula object not built by the same FormulaBuilder object"); } @@ -647,8 +557,6 @@ AnnotatedFormula FormulaBuilder::annotatedFormula(Formula f, Annotation a, vstri Term FormulaBuilder::substitute(Term original, Var v, Term t) { - CALL("FormulaBuilder::substitute(Term)"); - Kernel::TermList tgt = static_cast(t); SingleVarApplicator apl(v, tgt); Kernel::TermList resTerm = SubstHelper::apply(static_cast(original), apl); @@ -657,8 +565,6 @@ Term FormulaBuilder::substitute(Term original, Var v, Term t) Formula FormulaBuilder::substitute(Formula f, Var v, Term t) { - CALL("FormulaBuilder::substitute(Formula)"); - VList* fBound = f.form->boundVariables(); if(fBound->member(v)) { throw ApiException("Variable we substitute for cannot be bound in the formula"); @@ -681,16 +587,12 @@ Formula FormulaBuilder::substitute(Formula f, Var v, Term t) AnnotatedFormula FormulaBuilder::substitute(AnnotatedFormula af, Var v, Term t) { - CALL("FormulaBuilder::substitute(AnnotatedFormula)"); - Formula substForm = substitute(af.formula(), v, t); return annotatedFormula(substForm, af.annotation()); } Term FormulaBuilder::replaceConstant(Term original, Term replaced, Term target) { - CALL("FormulaBuilder::replaceConstant(Term)"); - Kernel::TermList trm = static_cast(original); Kernel::TermList tSrc = static_cast(replaced); Kernel::TermList tTgt = static_cast(target); @@ -713,8 +615,6 @@ Term FormulaBuilder::replaceConstant(Term original, Term replaced, Term target) Formula FormulaBuilder::replaceConstant(Formula f, Term replaced, Term target) { - CALL("FormulaBuilder::replaceConstant(Formula)"); - Kernel::TermList tSrc = static_cast(replaced); Kernel::TermList tTgt = static_cast(target); @@ -743,8 +643,6 @@ Formula FormulaBuilder::replaceConstant(Formula f, Term replaced, Term target) AnnotatedFormula FormulaBuilder::replaceConstant(AnnotatedFormula af, Term replaced, Term target) { - CALL("FormulaBuilder::replaceConstant(AnnotatedFormula)"); - Formula replForm = replaceConstant(af.formula(), replaced, target); return annotatedFormula(replForm, af.annotation()); } @@ -755,60 +653,44 @@ AnnotatedFormula FormulaBuilder::replaceConstant(AnnotatedFormula af, Term repla Term FormulaBuilder::term(const Function& c) { - CALL("FormulaBuilder::term/0"); - return _aux->term(c,0,0); } Term FormulaBuilder::term(const Function& f,const Term& t) { - CALL("FormulaBuilder::term/1"); - return _aux->term(f,&t,1); } Term FormulaBuilder::term(const Function& f,const Term& t1,const Term& t2) { - CALL("FormulaBuilder::term/2"); - Term args[]={t1, t2}; return _aux->term(f,args,2); } Term FormulaBuilder::term(const Function& f,const Term& t1,const Term& t2,const Term& t3) { - CALL("FormulaBuilder::term/3"); - Term args[]={t1, t2, t3}; return _aux->term(f,args,3); } Formula FormulaBuilder::formula(const Predicate& p) { - CALL("FormulaBuilder::formula/0"); - return _aux->atom(p,true,0,0); } Formula FormulaBuilder::formula(const Predicate& p,const Term& t) { - CALL("FormulaBuilder::formula/1"); - return _aux->atom(p,true,&t,1); } Formula FormulaBuilder::formula(const Predicate& p,const Term& t1,const Term& t2) { - CALL("FormulaBuilder::formula/2"); - Term args[]={t1, t2}; return _aux->atom(p,true,args,2); } Formula FormulaBuilder::formula(const Predicate& p,const Term& t1,const Term& t2,const Term& t3) { - CALL("FormulaBuilder::formula/3"); - Term args[]={t1, t2, t3}; return _aux->atom(p,true,args,3); } @@ -829,8 +711,6 @@ Term::Term(Kernel::TermList t, ApiHelper aux) : _aux(aux) vstring Term::toString() const { - CALL("Term::toString"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -839,8 +719,6 @@ vstring Term::toString() const bool Term::isVar() const { - CALL("Term::isVar"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -849,8 +727,6 @@ bool Term::isVar() const Var Term::var() const { - CALL("Term::var"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -862,8 +738,6 @@ Var Term::var() const Function Term::functor() const { - CALL("Term::functor"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -875,8 +749,6 @@ Function Term::functor() const unsigned Term::arity() const { - CALL("Term::arity"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -888,8 +760,6 @@ unsigned Term::arity() const Term Term::arg(unsigned i) { - CALL("Term::arg"); - if(isNull()) { throw ApiException("Term not initialized"); } @@ -904,8 +774,6 @@ Term Term::arg(unsigned i) Sort Term::sort() const { - CALL("Term::sort"); - if(!_aux->isFBHelper()) { throw ApiException("Sort can be retrieved only for terms created by the FormulaBuilder"); } @@ -923,8 +791,6 @@ Term::operator Kernel::TermList() const vstring Formula::toString() const { - CALL("Formula::toString"); - return _aux->toString(static_cast(*this)); } @@ -939,8 +805,6 @@ bool Formula::isNegation() const FormulaBuilder::Connective Formula::connective() const { - CALL("Formula::connective"); - switch(form->connective()) { case Kernel::LITERAL: ASS(form->literal()->isPositive()); @@ -972,8 +836,6 @@ FormulaBuilder::Connective Formula::connective() const Predicate Formula::predicate() const { - CALL("Formula::predicate"); - if(form->connective()!=Kernel::LITERAL) { throw ApiException("Predicate symbol can be retrieved only from atoms"); } @@ -982,8 +844,6 @@ Predicate Formula::predicate() const bool Formula::atomPolarity() const { - CALL("Formula::predicate"); - if(form->connective()!=Kernel::LITERAL) { throw ApiException("Polarity can be retrieved only from atoms"); } @@ -993,8 +853,6 @@ bool Formula::atomPolarity() const unsigned Formula::argCnt() const { - CALL("Formula::argCnt"); - switch(form->connective()) { case Kernel::LITERAL: return form->literal()->arity(); @@ -1020,8 +878,6 @@ unsigned Formula::argCnt() const Formula Formula::formulaArg(unsigned i) { - CALL("Formula::formulaArg"); - Kernel::Formula* res = 0; switch(form->connective()) { case Kernel::LITERAL: @@ -1064,8 +920,6 @@ Formula Formula::formulaArg(unsigned i) Term Formula::termArg(unsigned i) { - CALL("Formula::termArg"); - if(form->connective()!=Kernel::LITERAL) { throw ApiException("Term arguments can be obtained only from atoms"); } @@ -1077,8 +931,6 @@ Term Formula::termArg(unsigned i) StringIterator Formula::freeVars() { - CALL("Formula::freeVars"); - if(!form) { return StringIterator(VirtualIterator::getEmpty()); } @@ -1088,8 +940,6 @@ StringIterator Formula::freeVars() StringIterator Formula::boundVars() { - CALL("Formula::boundVars"); - if(!form) { return StringIterator(VirtualIterator::getEmpty()); } @@ -1099,15 +949,11 @@ StringIterator Formula::boundVars() vstring AnnotatedFormula::toString() const { - CALL("AnnotatedFormula::toString"); - return _aux->toString(unit); } vstring AnnotatedFormula::name() const { - CALL("AnnotatedFormula::toString"); - vstring unitName; if(!Parse::TPTP::findAxiomName(unit, unitName)) { unitName="u" + Int::toString(unit->number()); @@ -1117,8 +963,6 @@ vstring AnnotatedFormula::name() const StringIterator AnnotatedFormula::freeVars() { - CALL("AnnotatedFormula::freeVars"); - if(!unit) { return StringIterator(VirtualIterator::getEmpty()); } @@ -1134,8 +978,6 @@ StringIterator AnnotatedFormula::freeVars() StringIterator AnnotatedFormula::boundVars() { - CALL("AnnotatedFormula::boundVars"); - if(!unit || unit->isClause()) { return StringIterator(VirtualIterator::getEmpty()); } @@ -1145,8 +987,6 @@ StringIterator AnnotatedFormula::boundVars() FormulaBuilder::Annotation AnnotatedFormula::annotation() const { - CALL("AnnotatedFormula::annotation"); - switch(unit->inputType()) { case Kernel::Unit::AXIOM: return FormulaBuilder::AXIOM; @@ -1161,8 +1001,6 @@ FormulaBuilder::Annotation AnnotatedFormula::annotation() const Formula AnnotatedFormula::formula() { - CALL("AnnotatedFormula::formula"); - if(unit->isClause()) { throw ApiException("Cannot retrieve formula from clausified object"); } @@ -1184,8 +1022,6 @@ Formula AnnotatedFormula::formula() void AnnotatedFormula::assignName(AnnotatedFormula& form, vstring name) { - CALL("AnnotatedFormula::assignName"); - if(!OutputOptions::assignFormulaNames()) { return; } @@ -1214,8 +1050,6 @@ bool OutputOptions::_assignFormulaNames = true; void OutputOptions::setAssignFormulaNames(bool newVal) { - CALL("OutputOptions::setAssignFormulaNames"); - _assignFormulaNames = newVal; env.options->setOutputAxiomNames(newVal); } @@ -1226,15 +1060,11 @@ void OutputOptions::setAssignFormulaNames(bool newVal) StringIterator::StringIterator(const VirtualIterator& vit) { - CALL("StringIterator::StringIterator"); - _impl=new VirtualIterator(vit); } StringIterator::~StringIterator() { - CALL("StringIterator::~StringIterator"); - if(_impl) { delete _impl; } @@ -1242,8 +1072,6 @@ StringIterator::~StringIterator() StringIterator::StringIterator(const StringIterator& it) { - CALL("StringIterator::StringIterator(StringIterator&)"); - if(it._impl) { _impl=new VirtualIterator(*it._impl); } @@ -1254,8 +1082,6 @@ StringIterator::StringIterator(const StringIterator& it) StringIterator& StringIterator::operator=(const StringIterator& it) { - CALL("StringIterator::operator="); - VirtualIterator* oldImpl=_impl; if(it._impl) { @@ -1274,8 +1100,6 @@ StringIterator& StringIterator::operator=(const StringIterator& it) bool StringIterator::hasNext() { - CALL("StringIterator::hasNext"); - if(!_impl) { return false; } @@ -1285,8 +1109,6 @@ bool StringIterator::hasNext() vstring StringIterator::next() { - CALL("StringIterator::next"); - if(!hasNext()) { throw FormulaBuilderException("next() function called on a StringIterator object that contains no more elements"); } @@ -1302,19 +1124,16 @@ vstring StringIterator::next() std::ostream& operator<< (std::ostream& str,const Api::Sort& sort) { - CALL("operator<< (ostream&,const Api::Sort&)"); return str<sortName(sort); } ostream& operator<< (ostream& str,const Api::Formula& f) { - CALL("operator<< (ostream&,const Api::Formula&)"); return str<getPredicate(functor) : env.signature->getFunction(functor); @@ -79,8 +73,6 @@ vstring DefaultHelperCore::getDummyName(bool pred, unsigned functor) /** Get dummy name for function or predicate */ vstring DefaultHelperCore::getDummyName(const Kernel::Term* t) { - CALL("DefaultHelperCore::getDummyName/1"); - return getDummyName(t->isLiteral(), t->functor()); } @@ -107,8 +99,6 @@ vstring DefaultHelperCore::getSymbolName(const Kernel::Term* t) const vstring DefaultHelperCore::toString(const Kernel::Term* t0) const { - CALL("DefaultHelperCore::toString(const Kernel::Term*)"); - vstring res; if(t0->isSpecial()) { return t0->specialTermToString(); @@ -195,8 +185,6 @@ vstring DefaultHelperCore::toString(const Kernel::Term* t0) const vstring DefaultHelperCore::toString(const Kernel::Formula* f0) const { - CALL("DefaultHelperCore::toString(const Kernel::Formula*)"); - Kernel::Formula* f = const_cast(f0); static vstring names [] = @@ -278,8 +266,6 @@ vstring DefaultHelperCore::toString(const Kernel::Formula* f0) const vstring DefaultHelperCore::toString(const Kernel::Clause* clause) const { - CALL("DefaultHelperCore::toString(const Kernel::Clause*)"); - vstring res; Kernel::Clause::Iterator lits(*const_cast(clause)); if(lits.hasNext()) { @@ -308,8 +294,6 @@ vstring DefaultHelperCore::toString(const Kernel::Clause* clause) const */ vstring DefaultHelperCore::toString (const Kernel::Unit* unit0) const { - CALL("DefaultHelperCore::toString(const Kernel::Unit*)"); - Kernel::Unit* unit = const_cast(unit0); vstring prefix; vstring main = ""; @@ -400,8 +384,6 @@ struct DefaultHelperCore::Var2NameMapper StringIterator DefaultHelperCore::getVarNames(VList* l) { - CALL("DefaultHelperCore::getVarNames"); - VirtualIterator res=pvi( getPersistentIterator( getMappingIterator( VList::DestructiveIterator(l), @@ -421,8 +403,6 @@ StringIterator DefaultHelperCore::getVarNames(VList* l) /** build a term f(*args) with specified @b arity */ Term FBHelperCore::term(const Function& f,const Term* args, unsigned arity) { - CALL("FBHelperCore::term"); - if(f>=static_cast(env.signature->functions())) { throw FormulaBuilderException("Function does not exist"); } @@ -442,8 +422,6 @@ Term FBHelperCore::term(const Function& f,const Term* args, unsigned arity) /** build a predicate p(*args) with specified @b arity */ Formula FBHelperCore::atom(const Predicate& p, bool positive, const Term* args, unsigned arity) { - CALL("FBHelperCore::atom"); - if(p>=static_cast(env.signature->predicates())) { throw FormulaBuilderException("Predicate does not exist"); } @@ -464,8 +442,6 @@ Formula FBHelperCore::atom(const Predicate& p, bool positive, const Term* args, unsigned FBHelperCore::getUnaryPredicate() { - CALL("FBHelperCore::getUnaryPredicate"); - if(_unaryPredicate!=0) { return _unaryPredicate; } @@ -484,8 +460,6 @@ unsigned FBHelperCore::getUnaryPredicate() Sort FBHelperCore::getSort(const Api::Term t) { - CALL("FBHelperCore::getSort"); - if(t.isVar()) { unsigned v = t.var(); return getVarSort(v); @@ -498,8 +472,6 @@ Sort FBHelperCore::getSort(const Api::Term t) void FBHelperCore::ensureArgumentsSortsMatch(BaseType* type, const Api::Term* args) { - CALL("FBHelperCore::ensureArgumentsSortsMatch"); - unsigned arity = type->arity(); for(unsigned i=0; iarg(i); @@ -512,8 +484,6 @@ void FBHelperCore::ensureArgumentsSortsMatch(BaseType* type, const Api::Term* ar void FBHelperCore::ensureEqualityArgumentsSortsMatch(const Api::Term arg1, const Api::Term arg2) { - CALL("FBHelperCore::ensureEqualityArgumentsSortsMatch"); - Sort s1 = getSort(arg1); Sort s2 = getSort(arg2); if(s1!=s2) { @@ -523,8 +493,6 @@ void FBHelperCore::ensureEqualityArgumentsSortsMatch(const Api::Term arg1, const vstring FBHelperCore::getVarName(Var v) const { - CALL("FBHelperCore::getVarName"); - if(outputDummyNames()) { return "X"+Int::toString(v); } @@ -553,8 +521,6 @@ vstring FBHelperCore::getVarName(Var v) const Sort FBHelperCore::getVarSort(Var v) const { - CALL("FBHelperCore::getVarSort"); - Sort res; if(varSorts.find(v,res)) { return res; @@ -599,8 +565,6 @@ unsigned FBHelperCore::getVar(vstring varName, Sort varSort) void FBHelperCore::addAttribute(AttribStack& stack, vstring name, vstring value) { - CALL("FBHelperCore::addAttribute"); - AttribPair attr(name,value); //TODO: This causes quadratic complexity in the number of attributes if(stack.find(attr)) { @@ -615,8 +579,6 @@ void FBHelperCore::addAttribute(AttribStack& stack, vstring name, vstring value) */ unsigned FBHelperCore::FBVarFactory::getVarAlias(unsigned var) { - CALL("FBHelperCore::FBVarFactory::getVarAlias"); - vstring origName=_parent.getVarName(var); int i=0; vstring name; @@ -633,8 +595,6 @@ unsigned FBHelperCore::FBVarFactory::getVarAlias(unsigned var) */ vstring FBHelperCore::FBVarFactory::getVarName(unsigned var) { - CALL("FBHelperCore::FBVarFactory::getVarName"); - return _parent.getVarName(var); } @@ -647,15 +607,11 @@ ApiHelper::ApiHelper() : _obj(0) {} ApiHelper::~ApiHelper() { - CALL("ApiHelper::~ApiHelper"); - updRef(false); } ApiHelper::ApiHelper(const ApiHelper& h) { - CALL("ApiHelper::ApiHelper(ApiHelper&)"); - _obj=h._obj; updRef(true); } @@ -678,8 +634,6 @@ ApiHelper& ApiHelper::operator=(FBHelperCore* hc) void ApiHelper::updRef(bool inc) { - CALL("ApiHelper::updRef"); - if(_obj) { if(inc) { _obj->incRef(); @@ -692,29 +646,21 @@ void ApiHelper::updRef(bool inc) bool ApiHelper::operator==(const ApiHelper& h) const { - CALL("ApiHelper::operator=="); - return _obj==h._obj; } bool ApiHelper::operator!=(const ApiHelper& h) const { - CALL("ApiHelper::operator!="); - return _obj!=h._obj; } DefaultHelperCore* ApiHelper::operator->() const { - CALL("ApiHelper::operator->"); - return **this; } DefaultHelperCore* ApiHelper::operator*() const { - CALL("ApiHelper::operator*"); - if(_obj) { return _obj; } @@ -730,16 +676,12 @@ DefaultHelperCore* ApiHelper::operator*() const FBHelper::FBHelper() { - CALL("FBHelper::FBHelper"); - _obj=new FBHelperCore; updRef(true); } FBHelperCore* FBHelper::operator->() const { - CALL("FBHelper::operator->"); - ASS(_obj); return _obj; } diff --git a/Api/Helper_Internal.hpp b/Api/Helper_Internal.hpp index 0c84854f8..55fb14614 100644 --- a/Api/Helper_Internal.hpp +++ b/Api/Helper_Internal.hpp @@ -84,8 +84,6 @@ class FBHelperCore void incRef() { - CALL("ApiHelperCore::incRef"); - refCtr++; } @@ -97,7 +95,6 @@ class FBHelperCore */ void decRef() { - CALL("ApiHelperCore::decRef"); ASS_G(refCtr,0); refCtr--; @@ -143,7 +140,6 @@ class FBHelperCore AttribStack& getSortAttributes(unsigned srt) { - CALL("ApiHelperCore::getSortAttributes"); AttribStack* res; _sortAttributes.getValuePtr(srt, res); return *res; @@ -151,7 +147,6 @@ class FBHelperCore AttribStack& getPredicateAttributes(unsigned pred) { - CALL("ApiHelperCore::getPredicateAttributes"); AttribStack* res; _predicateAttributes.getValuePtr(pred, res); return *res; @@ -159,7 +154,6 @@ class FBHelperCore AttribStack& getFunctionAttributes(unsigned func) { - CALL("ApiHelperCore::getFunctionAttributes"); AttribStack* res; _functionAttributes.getValuePtr(func, res); return *res; diff --git a/Api/Problem.cpp b/Api/Problem.cpp index 9c5ae768c..b23193437 100644 --- a/Api/Problem.cpp +++ b/Api/Problem.cpp @@ -17,7 +17,6 @@ #include "Helper_Internal.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Deque.hpp" #include "Lib/DHMap.hpp" @@ -69,8 +68,6 @@ using namespace Lib; Problem::PreprocessingOptions::OptDataStore::OptDataStore() { - CALL("Problem::PreprocessingOptions::ARRStore::ARRStore()"); - lhs = new Stack(); posRhs = new Stack(); negRhs = new Stack(); @@ -81,8 +78,6 @@ Problem::PreprocessingOptions::OptDataStore::OptDataStore() Problem::PreprocessingOptions::OptDataStore::OptDataStore(const OptDataStore& o) { - CALL("Problem::PreprocessingOptions::ARRStore::ARRStore(const ARRStore&)"); - lhs = new Stack(*o.lhs); posRhs = new Stack(*o.posRhs); negRhs = new Stack(*o.negRhs); @@ -93,8 +88,6 @@ Problem::PreprocessingOptions::OptDataStore::OptDataStore(const OptDataStore& o) Problem::PreprocessingOptions::OptDataStore& Problem::PreprocessingOptions::OptDataStore::operator=(const OptDataStore& o) { - CALL("Problem::PreprocessingOptions::ARRStore::operator="); - *lhs = *o.lhs; *posRhs = *o.posRhs; *negRhs = *o.negRhs; @@ -106,8 +99,6 @@ Problem::PreprocessingOptions::OptDataStore& Problem::PreprocessingOptions::OptD Problem::PreprocessingOptions::OptDataStore::~OptDataStore() { - CALL("Problem::PreprocessingOptions::ARRStore::~ARRStore"); - delete lhs; delete posRhs; delete negRhs; @@ -118,8 +109,6 @@ Problem::PreprocessingOptions::OptDataStore::~OptDataStore() void Problem::PreprocessingOptions::OptDataStore::setDefaults() { - CALL("Problem::PreprocessingOptions::OptDataStore::setDefaults"); - lhs->reset(); posRhs->reset(); negRhs->reset(); @@ -131,15 +120,11 @@ void Problem::PreprocessingOptions::OptDataStore::setDefaults() Problem::PreprocessingOptions::PreprocessingOptions() { - CALL("Problem::PreprocessingOptions::PreprocessingOptions/0"); - setDefaults(); } Problem::PreprocessingOptions::PreprocessingOptions(vstring spec) { - CALL("Problem::PreprocessingOptions::PreprocessingOptions/1"); - setDefaults(); OptionsReader optReader; @@ -151,8 +136,6 @@ Problem::PreprocessingOptions::PreprocessingOptions(vstring spec) void Problem::PreprocessingOptions::prepareOptionsReader(OptionsReader& rdr) { - CALL("Problem::PreprocessingOptions::prepareOptionsReader"); - EnumReader enumPreprMode; enumPreprMode.addVal("selection_only", PM_SELECTION_ONLY); enumPreprMode.addVal("early_preprocessing", PM_EARLY_PREPROCESSING); @@ -209,8 +192,6 @@ void Problem::PreprocessingOptions::prepareOptionsReader(OptionsReader& rdr) void Problem::PreprocessingOptions::setDefaults() { - CALL("Problem::PreprocessingOptions::setDefaults"); - mode = PM_CLAUSIFY; namingThreshold = 8; preserveEpr = false; @@ -244,8 +225,6 @@ void Problem::PreprocessingOptions::setDefaults() void Problem::PreprocessingOptions::printOptionValues(ostream& out) { - CALL("Problem::PreprocessingOptions::printOptionValues"); - OptionsReader curRdr; prepareOptionsReader(curRdr); @@ -259,7 +238,6 @@ void Problem::PreprocessingOptions::printOptionValues(ostream& out) void Problem::PreprocessingOptions::addAsymmetricRewritingRule(Formula lhs, Formula posRhs, Formula negRhs, Formula dblRhs) { - CALL("Problem::PreprocessingOptions::addAsymmetricRewritingRule"); ASS_EQ(_ods.lhs->size(),_ods.posRhs->size()); ASS_EQ(_ods.lhs->size(),_ods.negRhs->size()); ASS_EQ(_ods.lhs->size(),_ods.dblRhs->size()); @@ -272,8 +250,6 @@ void Problem::PreprocessingOptions::addAsymmetricRewritingRule(Formula lhs, void Problem::PreprocessingOptions::importAssymmetricRulesFrom(const PreprocessingOptions& src) { - CALL("Problem::PreprocessingOptions::importAssymmetricRulesFrom"); - _ods.lhs = src._ods.lhs; _ods.posRhs = src._ods.posRhs; _ods.negRhs = src._ods.negRhs; @@ -286,8 +262,6 @@ void Problem::PreprocessingOptions::importAssymmetricRulesFrom(const Preprocessi struct Problem::PreprocessingOptions::Atom2LitFn { Kernel::Literal* operator()(Formula f) { - CALL("Problem::PreprocessingOptions::Atom2LitFn::operator()"); - Kernel::Formula* form = f.form; while(form->connective()==Kernel::NOT) { form = form->uarg(); @@ -302,8 +276,6 @@ struct Problem::PreprocessingOptions::Atom2LitFn void Problem::PreprocessingOptions::restrictPredicateEquivalenceDiscovery(size_t set1Sz, Formula* set1, size_t set2Sz, Formula* set2) { - CALL("Problem::PreprocessingOptions::restrictPredicateEquivalenceDiscovery"); - _predicateEquivalenceDiscoveryRestricted = true; _ods.pedSet1->reset(); _ods.pedSet1->loadFromIterator(getMappingIterator(getArrayishObjectIterator(set1, set1Sz),Atom2LitFn())); @@ -313,8 +285,6 @@ void Problem::PreprocessingOptions::restrictPredicateEquivalenceDiscovery(size_t void Problem::PreprocessingOptions::validate() const { - CALL("Problem::PreprocessingOptions::validate"); - if(namingThreshold>32767 || namingThreshold<0) { throw new ApiException("namingThreshold must be in the range [0,32767]"); } @@ -352,7 +322,6 @@ class Problem::PData void cloneInto(PData* obj) { - CALL("Problem::PData::cloneInto"); ASS_EQ(obj->_forms, 0); obj->_forms = AFList::copy(_forms); @@ -360,8 +329,6 @@ class Problem::PData void addFormula(AnnotatedFormula f) { - CALL("Problem::PData::addFormula"); - _size++; AFList::push(f, _forms); } @@ -372,13 +339,11 @@ class Problem::PData /** Problem must be non-empty */ ApiHelper getApiHelper() { - CALL("Problem::PData::getApiHelper"); ASS_G(size(),0); return _forms->head()._aux; } DefaultHelperCore* getCore() { - CALL("Problem::PData::getCore"); if(size()==0) { return 0; } return *getApiHelper(); } @@ -392,24 +357,18 @@ class Problem::PData Problem::Problem() { - CALL("Problem::Problem"); - _data=new PData; _data->incRef(); } Problem::Problem(const Problem& p) { - CALL("Problem::Problem(const Problem&)"); - _data=const_cast(p._data); _data->incRef(); } Problem& Problem::operator=(const Problem& p) { - CALL("Problem::operator ="); - PData* oldData=_data; _data=const_cast(p._data); @@ -422,15 +381,11 @@ Problem& Problem::operator=(const Problem& p) Problem::~Problem() { - CALL("Problem::~Problem"); - _data->decRef(); } Problem Problem::clone() { - CALL("Problem::clone"); - Problem res; _data->cloneInto(res._data); return res; @@ -438,22 +393,16 @@ Problem Problem::clone() void Problem::addFormula(AnnotatedFormula f) { - CALL("Problem::addFormula"); - _data->addFormula(f); } size_t Problem::size() { - CALL("Problem::size"); - return _data->size(); } bool Problem::empty() { - CALL("Problem::empty"); - return size()==0; } @@ -464,8 +413,6 @@ bool Problem::empty() void Problem::addFromStream(istream& s, vstring includeDirectory, bool simplifySyntax) { - CALL("Problem::addFromStream"); - using namespace Shell; vstring originalInclude=env.options->include(); @@ -501,8 +448,6 @@ class Problem::ProblemTransformer Problem transform(Problem p) { - CALL("ProblemTransformer::transform(Problem)"); - VarManager::VarFactory* oldFactory = VarManager::varNamePreservingFactory(); if(p.size()>0) { @@ -535,8 +480,6 @@ class Problem::ProblemTransformer virtual void transformImpl(Problem p) { - CALL("ProblemTransformer::transformImpl(Problem)"); - AnnotatedFormulaIterator fit=p.formulas(); while(fit.hasNext()) { AnnotatedFormula f=fit.next(); @@ -549,7 +492,6 @@ class Problem::ProblemTransformer */ void transform(AnnotatedFormula f) { - CALL("Problem::ProblemTransformer::transform(AnnotatedFormula)"); ASS(!_transforming); ASS(_defs.isEmpty()); @@ -576,7 +518,6 @@ class Problem::ProblemTransformer void addUnit(Kernel::Unit* unit) { - CALL("Problem::ProblemTransformer::addUnit"); ASS(unit); AnnotatedFormula af = AnnotatedFormula(unit, _origAF._aux); @@ -600,8 +541,6 @@ class Problem::ProblemTransformer void handleDefs(Kernel::UnitList*& defLst) { - CALL("Problem::ProblemTransformer::addUnit"); - while(defLst) { _defs.push_back(Kernel::UnitList::pop(defLst)); } @@ -625,8 +564,6 @@ class Problem::Preprocessor1 : public ProblemTransformer protected: void transformImpl(Kernel::Unit* unit) { - CALL("Problem::Preprocessor1::transformImpl"); - using namespace Shell; if(unit->isClause()) { @@ -655,8 +592,6 @@ class Problem::VariableEqualityPropagator : public ProblemTransformer protected: void transformImpl(Kernel::Unit* unit) { - CALL("Problem::VariableEqualityPropagator::transformImpl"); - addUnit(_eqProp.apply(unit)); } EqualityPropagator _eqProp; @@ -669,8 +604,6 @@ class Problem::BDDSweeper : public ProblemTransformer protected: void transformImpl(Kernel::Unit* unit) { - CALL("Problem::BDDSweeper::transformImpl"); - Kernel::Unit* res; if(!_act.apply(unit, res)) { addUnit(unit); @@ -694,8 +627,6 @@ class Problem::AIGInliner : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::BDDSweeper::transformImpl(Problem)"); - Kernel::UnitList* units = 0; AnnotatedFormulaIterator fit=p.formulas(); @@ -715,8 +646,6 @@ class Problem::AIGInliner : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::BDDSweeper::transformImpl"); - Unit* res; if(!_aii.apply(unit, res)) { addUnit(unit); @@ -739,8 +668,6 @@ class Problem::AIGDefinitionIntroducer : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::AIGDefinitionIntroducer::transformImpl(Problem)"); - Kernel::UnitList* units = 0; AnnotatedFormulaIterator fit=p.formulas(); @@ -769,8 +696,6 @@ class Problem::AIGDefinitionIntroducer : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::AIGDefinitionIntroducer::transformImpl"); - Unit* res; if(!_adi.apply(unit, res)) { addUnit(unit); @@ -788,8 +713,6 @@ class Problem::AIGConditionalRewriter public: Problem transform(Problem p) { - CALL("AIGConditionalRewriter::transform"); - Kernel::UnitList* units = 0; AnnotatedFormulaIterator fit=p.formulas(); @@ -826,8 +749,6 @@ class Problem::PredicateIndexIntroducer : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::PredicateIndexIntroducer::transformImpl(Problem)"); - Kernel::UnitList* units = 0; AnnotatedFormulaIterator fit=p.formulas(); @@ -847,8 +768,6 @@ class Problem::PredicateIndexIntroducer : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::PredicateIndexIntroducer::transformImpl"); - Unit* res; if(!_pii.apply(unit, res)) { addUnit(unit); @@ -866,8 +785,6 @@ class Problem::TopLevelFlattener : public ProblemTransformer protected: virtual void transformImpl(Kernel::Unit* unit) { - CALL("Problem::EPRRestoringInliner::transformImpl"); - if(unit->isClause()) { addUnit(unit); return; @@ -900,8 +817,6 @@ class Problem::PredicateDefinitionMerger : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::PredicateDefinitionMerger::transformImpl(Problem)"); - Kernel::UnitList* units = 0; AnnotatedFormulaIterator fit=p.formulas(); @@ -921,8 +836,6 @@ class Problem::PredicateDefinitionMerger : public ProblemTransformer virtual void transformImpl(Kernel::Unit* unit) { - CALL("Problem::PredicateDefinitionMerger::transformImpl"); - Kernel::Unit* res = _merger.apply(unit); if(res) { addUnit(res); @@ -943,8 +856,6 @@ class Problem::PredicateDefinitionInliner : public ProblemTransformer bool addAsymetricDefinition(Formula lhs, Formula posRhs, Formula negRhs, Formula dblRhs) { - CALL("Problem::PredicateDefinitionInliner::addAsymetricDefinition"); - Kernel::Formula* lhsF = lhs; bool negate = false; while(lhsF->connective()==Kernel::NOT) { @@ -969,8 +880,6 @@ class Problem::PredicateDefinitionInliner : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::PredicateDefinitionInliner::transformImpl(Problem)"); - static DHSet defs; defs.reset(); @@ -1045,8 +954,6 @@ class Problem::PredicateDefinitionInliner : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::PredicateDefinitionInliner::transformImpl"); - Kernel::Unit* res = _pdInliner.apply(unit); if(res) { addUnit(res); @@ -1068,8 +975,6 @@ class Problem::EPRRestoringInliner : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::EPRRestoringInliner::transformImpl(Problem)"); - p = PredicateDefinitionInliner(INL_PREDICATE_EQUIVALENCES_ONLY).transform(p); Kernel::UnitList* units = 0; @@ -1091,8 +996,6 @@ class Problem::EPRRestoringInliner : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::EPRRestoringInliner::transformImpl"); - Kernel::Unit* res = _eprInliner.apply(unit); if(res) { addUnit(res); @@ -1107,8 +1010,6 @@ class Problem::ConstantSkolemizer : public ProblemTransformer protected: void transformImpl(Kernel::Unit* unit) { - CALL("Problem::ConstantSkolemizer::transformImpl"); - if(unit->isClause()) { addUnit(unit); return; @@ -1129,8 +1030,6 @@ class Problem::EPRSkolemizer : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::EPRRestoringInliner::transformImpl(Problem)"); - p = ConstantSkolemizer().transform(p); p = PredicateDefinitionInliner(INL_PREDICATE_EQUIVALENCES_ONLY).transform(p); @@ -1153,8 +1052,6 @@ class Problem::EPRSkolemizer : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::EPRRestoringInliner::transformImpl"); - UnitList* res = 0; if(!_eprSkolem.apply(unit, res)) { addUnit(unit); @@ -1181,7 +1078,6 @@ class Problem::UnusedPredicateDefinitionRemover : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::UnusedPredicateDefinitionRemover::transformImpl(Problem)"); ASS(replacements.isEmpty()); //this function can be called only once per instance of this class Kernel::UnitList* units = 0; @@ -1203,8 +1099,6 @@ class Problem::UnusedPredicateDefinitionRemover : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::UnusedPredicateDefinitionRemover::transformImpl"); - Kernel::Unit* v; if(!replacements.find(unit,v)) { addUnit(unit); @@ -1235,8 +1129,6 @@ class Problem::PredicateEquivalenceDiscoverer Problem transform(Problem p) { - CALL("PredicateEquivalenceDiscoverer::transform"); - if(p.empty()) { return p; } @@ -1324,7 +1216,6 @@ class Problem::SineSelector : public ProblemTransformer protected: virtual void transformImpl(Problem p) { - CALL("Problem::SineSelector::transformImpl(Problem)"); ASS(selected.isEmpty()); //this function can be called only once per instance of this class Kernel::UnitList* units = 0; @@ -1351,8 +1242,6 @@ class Problem::SineSelector : public ProblemTransformer void transformImpl(Kernel::Unit* unit) { - CALL("Problem::SineSelector::transformImpl"); - if(selected.find(unit)) { addUnit(unit); } @@ -1372,8 +1261,6 @@ class Problem::Clausifier : public ProblemTransformer protected: void transformImpl(Kernel::Unit* unit) { - CALL("Problem::Clausifier::transformImpl"); - using namespace Shell; if(unit->isClause()) { @@ -1425,8 +1312,6 @@ class Problem::Clausifier : public ProblemTransformer Problem Problem::clausify(int namingThreshold, bool preserveEpr, InliningMode predicateDefinitionInlining, bool unusedPredicateDefinitionRemoval) { - CALL("Problem::clausify"); - PreprocessingOptions opts; opts.mode = PM_CLAUSIFY; opts.namingThreshold = namingThreshold; @@ -1440,8 +1325,6 @@ Problem Problem::clausify(int namingThreshold, bool preserveEpr, InliningMode pr Problem Problem::skolemize(int namingThreshold, bool preserveEpr, InliningMode predicateDefinitionInlining, bool unusedPredicateDefinitionRemoval) { - CALL("Problem::skolemize"); - PreprocessingOptions opts; opts.mode = PM_SKOLEMIZE; opts.namingThreshold = namingThreshold; @@ -1454,8 +1337,6 @@ Problem Problem::skolemize(int namingThreshold, bool preserveEpr, InliningMode p Problem Problem::inlinePredicateDefinitions(InliningMode mode) { - CALL("Problem::inlinePredicateDefinitions"); - if(mode==INL_OFF) { throw ApiException("Cannot perform definition inlining in function inlinePredicateDefinitions(InliningMode) with mode INL_OFF"); } @@ -1470,8 +1351,6 @@ Problem Problem::inlinePredicateDefinitions(InliningMode mode) Problem Problem::removeUnusedPredicateDefinitions() { - CALL("Problem::removeUnusedPredicateDefinitions"); - PreprocessingOptions opts; opts.mode = PM_EARLY_PREPROCESSING; opts.predicateDefinitionInlining = INL_OFF; @@ -1482,8 +1361,6 @@ Problem Problem::removeUnusedPredicateDefinitions() Problem Problem::preprocessInStages(size_t stageCount, const PreprocessingOptions* stageSpecs) { - CALL("Problem::preprocessInStages"); - Problem res = *this; for(size_t idx=0; idx singleSpecs; StringUtils::splitStr(stagesStr.c_str(), ';', singleSpecs); @@ -1515,8 +1390,6 @@ void Problem::readStageSpecs(vstring stagesStr, size_t& stageCnt, PreprocessingO Problem Problem::preprocessInStages(vstring stagesStr) { - CALL("Problem::preprocessInStages"); - size_t stageCnt; PreprocessingOptions* stageSpecs; @@ -1530,8 +1403,6 @@ Problem Problem::preprocessInStages(vstring stagesStr) Problem Problem::singlePreprocessingIteration(const PreprocessingOptions& options) { - CALL("Problem::singlePreprocessingIteration"); - Problem res = *this; if(options.sineSelection) { @@ -1626,7 +1497,6 @@ Problem Problem::singlePreprocessingIteration(const PreprocessingOptions& option Problem Problem::preprocess(const PreprocessingOptions& options) { - CALL("Problem::preprocess"); options.validate(); Problem res = *this; @@ -1655,8 +1525,6 @@ Problem Problem::preprocess(const PreprocessingOptions& options) bool Problem::fixpointReached(FixpointCheck fc, Problem& oldPrb, Problem& newPrb) { - CALL("Problem::fixpointReached"); - switch(fc) { case FC_NONE: return false; @@ -1669,16 +1537,12 @@ bool Problem::fixpointReached(FixpointCheck fc, Problem& oldPrb, Problem& newPrb Problem Problem::performAsymetricRewriting(Formula lhs, Formula posRhs, Formula negRhs, Formula dblRhs) { - CALL("Problem::performAsymetricRewriting"); - return performAsymetricRewriting(1, &lhs, &posRhs, &negRhs, &dblRhs); } Problem Problem::performAsymetricRewriting(size_t cnt, Formula* lhsArray, Formula* posRhsArray, Formula* negRhsArray, Formula* dblRhsArray) { - CALL("Problem::performAsymetricRewriting"); - Problem res = Preprocessor1().transform(*this); PredicateDefinitionInliner inl(INL_NO_DISCOVERED_DEFS); for(size_t i=0; igetFunction(symNumber) : env.signature->getPredicate(symNumber); @@ -1758,8 +1618,6 @@ void outputSymbolTypeDefinitions(ostream& out, unsigned symNumber, bool function void Problem::outputTypeDefinitions(ostream& out, bool outputAllTypeDefs) { - CALL("Problem::outputTypeDefinitions"); - DefaultHelperCore* core0 = _data->getCore(); bool dummyNames = core0 && core0->outputDummyNames(); FBHelperCore* core = (core0 && core0->isFBHelper()) ? static_cast(core0) : 0; @@ -1785,8 +1643,6 @@ void Problem::outputTypeDefinitions(ostream& out, bool outputAllTypeDefs) void Problem::output(ostream& out, bool outputTypeDefs, bool outputAllTypeDefs) { - CALL("Problem::output"); - if(outputTypeDefs) { outputTypeDefinitions(out, outputAllTypeDefs); } @@ -1798,8 +1654,6 @@ void Problem::output(ostream& out, bool outputTypeDefs, bool outputAllTypeDefs) void Problem::outputStatistics(ostream& out) { - CALL("Problem::outputStatictics"); - env.statistics->print(out); } @@ -1808,8 +1662,6 @@ void Problem::outputStatistics(ostream& out) bool AnnotatedFormulaIterator::hasNext() { - CALL("AnnotatedFormulaIterator::hasNext"); - AFList** plst=static_cast(idata); if(ready) { @@ -1825,8 +1677,6 @@ bool AnnotatedFormulaIterator::hasNext() AnnotatedFormula AnnotatedFormulaIterator::next() { - CALL("AnnotatedFormulaIterator::next"); - AFList** plst=static_cast(idata); ASS(ready); ASS(*plst); //we're not at the end of the list @@ -1836,8 +1686,6 @@ AnnotatedFormula AnnotatedFormulaIterator::next() void AnnotatedFormulaIterator::del() { - CALL("AnnotatedFormulaIterator::del"); - AFList** plst=static_cast(idata); ASS(*plst); //we're not at the end of the list @@ -1849,8 +1697,6 @@ void AnnotatedFormulaIterator::del() AnnotatedFormulaIterator Problem::formulas() { - CALL("Problem::formulas"); - AnnotatedFormulaIterator res; res.idata=&_data->forms(); res.ready=true; diff --git a/Api/ResourceLimits.cpp b/Api/ResourceLimits.cpp index fd4e11e70..136ba91ed 100644 --- a/Api/ResourceLimits.cpp +++ b/Api/ResourceLimits.cpp @@ -53,8 +53,6 @@ __InitHelper initializerAuxObject; void ResourceLimits::setLimits(size_t memoryInBytes, int timeInDeciseconds) { - CALL("ResourceLimits::setLimits"); - env.options->setMemoryLimitOptionValue(memoryInBytes); Allocator::setMemoryLimit(memoryInBytes); diff --git a/Api/Tracing.cpp b/Api/Tracing.cpp index a6b209154..46ee871c6 100644 --- a/Api/Tracing.cpp +++ b/Api/Tracing.cpp @@ -12,7 +12,6 @@ * Implements class Tracing. */ -#include "Debug/Tracer.hpp" #include "Tracing.hpp" @@ -23,28 +22,22 @@ unsigned Tracing::s_traceStackDepth = 0; void Tracing::enableTrace(vstring traceName, unsigned depth) { - CALL("Tracing::enableTrace"); ENABLE_TAG_LIMITED(traceName.c_str(), depth); } void Tracing::processTraceString(vstring str) { - CALL("Tracing::processTraceString"); PROCESS_TRACE_SPEC_STRING(str); } void Tracing::pushTracingState() { - CALL("Tracing::pushTracingState"); - PUSH_TAG_STATES(); s_traceStackDepth++; } void Tracing::popTracingState() { - CALL("Tracing::popTracingState"); - if(s_traceStackDepth==0) { throw "No pushed tracing state left to be popped"; } @@ -54,7 +47,6 @@ void Tracing::popTracingState() void Tracing::displayHelp() { - CALL("Tracing::displayHelp"); DISPLAY_HELP(); } */ diff --git a/CASC/CLTBMode.cpp b/CASC/CLTBMode.cpp index 014f8cc14..3dacfe20f 100644 --- a/CASC/CLTBMode.cpp +++ b/CASC/CLTBMode.cpp @@ -62,8 +62,6 @@ using namespace Saturation; */ void CLTBMode::perform() { - CALL("CLTBMode::perform"); - if (env.options->inputFile() == "") { USER_ERROR("Input file must be specified for ltb mode"); } @@ -126,8 +124,6 @@ void CLTBMode::perform() */ void CLTBMode::solveBatch(istream& batchFile, bool first,vstring inputDirectory) { - CALL("CLTBMode::solveBatch(istream& batchfile)"); - // this is the time in milliseconds since the start when this batch file should terminate _timeUsedByPreviousBatches = env.timer->elapsedMilliseconds(); coutLineOutput() << "Starting Vampire on the batch file " << "\n"; @@ -243,8 +239,6 @@ void CLTBMode::solveBatch(istream& batchFile, bool first,vstring inputDirectory) void CLTBMode::loadIncludes() { - CALL("CLTBMode::loadIncludes"); - UnitList* theoryAxioms=0; { TIME_TRACE(TimeTrace::PARSING); @@ -284,8 +278,6 @@ void CLTBMode::loadIncludes() void CLTBMode::learnFromSolutionFile(vstring& solnFileName) { - CALL("CLTBMode::learnFromSolutionFile"); - ifstream soln(solnFileName.c_str()); if (soln.fail()) { return; // ignore if we cannot get the solution file @@ -380,8 +372,6 @@ void CLTBMode::learnFromSolutionFile(vstring& solnFileName) void CLTBMode::doTraining() { - CALL("CLTBMode::doTraining"); - env.beginOutput(); env.out() << "Training in LTB currently unsupported" << endl; env.endOutput(); @@ -426,8 +416,6 @@ void CLTBMode::doTraining() */ int CLTBMode::readInput(istream& in, bool first) { - CALL("CLTBMode::readInput"); - vstring line, word; if(first){ @@ -634,7 +622,6 @@ void CLTBProblem::fillSchedule(Schedule& sched,const Shell::Property* property,i */ void CLTBProblem::performStrategy(int terminationTime,int timeLimit,Category category,const Shell::Property* property) { - CALL("CLTBProblem::performStrategy"); cout << "% Hi Geoff, go and have some cold beer while I am trying to solve this very hard problem!\n"; Schedule quick; @@ -668,7 +655,6 @@ void CLTBProblem::performStrategy(int terminationTime,int timeLimit,Category cat */ void CLTBProblem::searchForProof(int terminationTime,int timeLimit,const Category category) { - CALL("CLTBProblem::searchForProof"); TIME_TRACE("search for proof") System::registerForSIGHUPOnParentDeath(); @@ -745,8 +731,6 @@ void CLTBProblem::searchForProof(int terminationTime,int timeLimit,const Categor */ void CLTBProblem::exitOnNoSuccess() { - CALL("CLTBProblem::exitOnNoSuccess"); - env.beginOutput(); CLTBMode::lineOutput() << "Proof not found in time " << Timer::msToSecondsString(env.timer->elapsedMilliseconds()) << endl; if (env.remainingTime()/100>0) { @@ -778,8 +762,6 @@ static unsigned milliToDeci(unsigned timeInMiliseconds) { */ bool CLTBProblem::runSchedule(Schedule& schedule,StrategySet& used,int terminationTime) { - CALL("CLTBProblem::runSchedule"); - // compute the number of parallel processes depending on the // number of available cores int parallelProcesses; @@ -884,7 +866,6 @@ bool CLTBProblem::runSchedule(Schedule& schedule,StrategySet& used,int terminati */ void CLTBProblem::waitForChildAndExitWhenProofFound() { - CALL("CLTBProblem::waitForChildAndExitWhenProofFound"); ASS(!childIds.isEmpty()); int resValue; @@ -925,8 +906,6 @@ void CLTBProblem::terminatingSignalHandler(int sigNum) */ void CLTBProblem::runSlice(vstring sliceCode, unsigned timeLimitInMilliseconds) { - CALL("CLTBProblem::runSlice"); - Options opt = *env.options; opt.readFromEncodedOptions(sliceCode); opt.setTimeLimitInDeciseconds(milliToDeci(timeLimitInMilliseconds)); @@ -944,7 +923,6 @@ void CLTBProblem::runSlice(vstring sliceCode, unsigned timeLimitInMilliseconds) */ void CLTBProblem::runSlice(Options& strategyOpt) { - CALL("CLTBProblem::runSlice(Option&)"); TIME_TRACE_NEW_ROOT("run slice") System::registerForSIGHUPOnParentDeath(); @@ -1011,8 +989,6 @@ void CLTBProblem::runSlice(Options& strategyOpt) */ unsigned CLTBProblem::getSliceTime(vstring sliceCode,vstring& chopped) { - CALL("CASCMode::getSliceTime"); - unsigned pos = sliceCode.find_last_of('_'); vstring sliceTimeStr = sliceCode.substr(pos+1); chopped.assign(sliceCode.substr(0,pos)); @@ -1036,7 +1012,6 @@ unsigned CLTBProblem::getSliceTime(vstring sliceCode,vstring& chopped) */ ostream& CLTBMode::lineOutput() { - CALL("CLTBMode::lineOutput"); return env.out() << "% (" << getpid() << ',' << (env.timer->elapsedMilliseconds()/100)/10.0 << ") "; } // CLTBMode::lineOutput @@ -1048,6 +1023,5 @@ ostream& CLTBMode::lineOutput() */ ostream& CLTBMode::coutLineOutput() { - CALL("CLTBMode::lineOutput"); return cout << "% (" << getpid() << ',' << (env.timer->elapsedMilliseconds()/100)/10.0 << ") "; } // CLTBMode::coutLineOutput diff --git a/CASC/CLTBModeLearning.cpp b/CASC/CLTBModeLearning.cpp index c2ddb2373..2301e60c2 100644 --- a/CASC/CLTBModeLearning.cpp +++ b/CASC/CLTBModeLearning.cpp @@ -64,7 +64,6 @@ DHMap*> CLTBModeLearning::stratWins; */ void CLTBModeLearning::perform() { - CALL("CLTBModeLearning::perform"); TIME_TRACE("cltb learning"); if (env.options->inputFile() == "") { @@ -129,8 +128,6 @@ void CLTBModeLearning::perform() */ void CLTBModeLearning::solveBatch(istream& batchFile, bool first,vstring inputDirectory) { - CALL("CLTBModeLearning::solveBatch(istream& batchfile)"); - // fill the global strats up fillSchedule(strats); @@ -272,8 +269,6 @@ void CLTBModeLearning::solveBatch(istream& batchFile, bool first,vstring inputDi void CLTBModeLearning::loadIncludes() { - CALL("CLTBModeLearning::loadIncludes"); - UnitList* theoryAxioms=0; { TIME_TRACE(TimeTrace::PARSING); @@ -312,8 +307,6 @@ void CLTBModeLearning::loadIncludes() void CLTBModeLearning::doTraining(int time, bool startup) { - CALL("CLTBModeLearning::doTraining"); - static Stack::Iterator* prob_iter = 0; if(startup || (prob_iter && !prob_iter->hasNext())){ @@ -496,8 +489,6 @@ void CLTBModeLearning::doTraining(int time, bool startup) */ int CLTBModeLearning::readInput(istream& in, bool first) { - CALL("CLTBModeLearning::readInput"); - vstring line, word; if(first){ @@ -797,7 +788,6 @@ void CLTBModeLearning::fillSchedule(CLTBModeLearning::Schedule& sched) { */ void CLTBProblemLearning::performStrategy(int terminationTime,int timeLimit, Shell::Property* property,Schedule& quick, bool stopOnProof) { - CALL("CLTBProblemLearning::performStrategy"); cout << "% Hi Geoff, go and have some cold beer while I am trying to solve this very hard problem!\n"; Schedule fallback; @@ -827,8 +817,6 @@ void CLTBProblemLearning::performStrategy(int terminationTime,int timeLimit, Sh */ void CLTBProblemLearning::searchForProof(int terminationTime,int timeLimit, Schedule& strats, bool stopOnProof) { - CALL("CLTBProblemLearning::searchForProof"); - System::registerForSIGHUPOnParentDeath(); env.options->setInputFile(problemFile); @@ -885,8 +873,6 @@ void CLTBProblemLearning::searchForProof(int terminationTime,int timeLimit, Sche */ void CLTBProblemLearning::exitOnNoSuccess() { - CALL("CLTBProblemLearning::exitOnNoSuccess"); - env.beginOutput(); CLTBModeLearning::lineOutput() << "Proof not found in time " << Timer::msToSecondsString(env.timer->elapsedMilliseconds()) << endl; if (env.remainingTime()/100>0) { @@ -918,8 +904,6 @@ static unsigned milliToDeci(unsigned timeInMiliseconds) { */ bool CLTBProblemLearning::runSchedule(Schedule& schedule,StrategySet& used,bool fallback,int terminationTime, bool stopOnProof) { - CALL("CLTBProblemLearning::runSchedule"); - // compute the number of parallel processes depending on the // number of available cores int parallelProcesses; @@ -1023,7 +1007,6 @@ bool CLTBProblemLearning::runSchedule(Schedule& schedule,StrategySet& used,bool */ void CLTBProblemLearning::waitForChildAndExitWhenProofFound(bool stopOnProof) { - CALL("CLTBProblemLearning::waitForChildAndExitWhenProofFound"); ASS(!childIds.isEmpty()); int resValue; @@ -1064,8 +1047,6 @@ void CLTBProblemLearning::terminatingSignalHandler(int sigNum) */ void CLTBProblemLearning::runSlice(vstring sliceCode, unsigned timeLimitInMilliseconds,bool printProof) { - CALL("CLTBProblemLearning::runSlice"); - if(!printProof){ // We're learning, don't run again if already run ProbRecord* rec; @@ -1095,8 +1076,6 @@ void CLTBProblemLearning::runSlice(vstring sliceCode, unsigned timeLimitInMillis */ void CLTBProblemLearning::runSlice(Options& strategyOpt, bool printProof) { - CALL("CLTBProblemLearning::runSlice(Option&)"); - System::registerForSIGHUPOnParentDeath(); //UIHelper::cascModeChild=true; //UIHelper::cascMode=true; @@ -1184,8 +1163,6 @@ void CLTBProblemLearning::runSlice(Options& strategyOpt, bool printProof) */ unsigned CLTBProblemLearning::getSliceTime(vstring sliceCode,vstring& chopped) { - CALL("CASCMode::getSliceTime"); - unsigned pos = sliceCode.find_last_of('_'); vstring sliceTimeStr = sliceCode.substr(pos+1); chopped.assign(sliceCode.substr(0,pos)); @@ -1209,7 +1186,6 @@ unsigned CLTBProblemLearning::getSliceTime(vstring sliceCode,vstring& chopped) */ ostream& CLTBModeLearning::lineOutput() { - CALL("CLTBModeLearning::lineOutput"); return env.out() << "% (" << getpid() << ',' << (env.timer->elapsedMilliseconds()/100)/10.0 << ") "; } // CLTBModeLearning::lineOutput @@ -1221,7 +1197,6 @@ ostream& CLTBModeLearning::lineOutput() */ ostream& CLTBModeLearning::coutLineOutput() { - CALL("CLTBModeLearning::lineOutput"); return cout << "% (" << getpid() << ',' << (env.timer->elapsedMilliseconds()/100)/10.0 << ") "; } // CLTBModeLearning::coutLineOutput diff --git a/CASC/PortfolioMode.cpp b/CASC/PortfolioMode.cpp index 705ed0f4d..a60203e80 100644 --- a/CASC/PortfolioMode.cpp +++ b/CASC/PortfolioMode.cpp @@ -81,8 +81,6 @@ PortfolioMode::PortfolioMode() : _slowness(1.0), _syncSemaphore(2) { */ bool PortfolioMode::perform(float slowness) { - CALL("PortfolioMode::perform"); - PortfolioMode pm; pm._slowness = slowness; @@ -129,8 +127,6 @@ bool PortfolioMode::perform(float slowness) bool PortfolioMode::searchForProof() { - CALL("PortfolioMode::searchForProof"); - _prb = UIHelper::getInputProblem(*env.options); /* CAREFUL: Make sure that the order @@ -168,8 +164,6 @@ bool PortfolioMode::searchForProof() bool PortfolioMode::prepareScheduleAndPerform(const Shell::Property& prop) { - CALL("PortfolioMode::prepareScheduleAndPerform"); - // this is the one and only schedule that will leave this function // we fill it up in various ways Schedule schedule; @@ -192,8 +186,6 @@ bool PortfolioMode::prepareScheduleAndPerform(const Shell::Property& prop) // a (temporary) helper lambda that will go away as soon as we have new schedules from spider auto additionsSinceTheLastSpiderings = [&prop](const Schedule& sOrig, Schedule& sWithExtras) { - CALL("PortfolioMode::prepareScheduleAndPerform-additionsSinceTheLastSpiderings"); - // Always try these addScheduleExtra(sOrig,sWithExtras,"si=on:rtra=on:rawr=on:rp=on"); // shuffling options addScheduleExtra(sOrig,sWithExtras,"sp=frequency"); // frequency sp; this is in casc19 but not smt18 @@ -295,8 +287,6 @@ bool PortfolioMode::prepareScheduleAndPerform(const Shell::Property& prop) */ void PortfolioMode::rescaleScheduleLimits(const Schedule& sOld, Schedule& sNew, float limit_multiplier) { - CALL("PortfolioMode::rescaleScheduleLimits"); - Schedule::BottomFirstIterator it(sOld); while(it.hasNext()){ vstring s = it.next(); @@ -337,8 +327,6 @@ void PortfolioMode::rescaleScheduleLimits(const Schedule& sOld, Schedule& sNew, */ void PortfolioMode::addScheduleExtra(const Schedule& sOld, Schedule& sNew, vstring extra) { - CALL("PortfolioMode::addScheduleExtra"); - Schedule::BottomFirstIterator it(sOld); while(it.hasNext()){ vstring s = it.next(); @@ -355,8 +343,6 @@ void PortfolioMode::addScheduleExtra(const Schedule& sOld, Schedule& sNew, vstri void PortfolioMode::getSchedules(const Property& prop, Schedule& quick, Schedule& fallback) { - CALL("PortfolioMode::getSchedules"); - switch(env.options->schedule()) { case Options::Schedule::FILE: Schedules::getScheduleFromFile(env.options->scheduleFile(), quick); @@ -424,7 +410,6 @@ void PortfolioMode::getSchedules(const Property& prop, Schedule& quick, Schedule } bool PortfolioMode::runSchedule(Schedule schedule) { - CALL("PortfolioMode::runSchedule"); TIME_TRACE("run schedule"); Schedule::BottomFirstIterator it(schedule); @@ -502,8 +487,6 @@ bool PortfolioMode::runSchedule(Schedule schedule) { */ bool PortfolioMode::runScheduleAndRecoverProof(Schedule schedule) { - CALL("PortfolioMode::runScheduleAndRecoverProof"); - if (schedule.size() == 0) return false; @@ -551,8 +534,6 @@ bool PortfolioMode::runScheduleAndRecoverProof(Schedule schedule) */ unsigned PortfolioMode::getSliceTime(const vstring &sliceCode) { - CALL("PortfolioMode::getSliceTime"); - unsigned pos = sliceCode.find_last_of('_'); vstring sliceTimeStr = sliceCode.substr(pos+1); unsigned sliceTime; @@ -593,7 +574,6 @@ unsigned PortfolioMode::getSliceTime(const vstring &sliceCode) */ void PortfolioMode::runSlice(vstring sliceCode, int timeLimitInDeciseconds) { - CALL("PortfolioMode::runSlice"); TIME_TRACE("run slice"); int sliceTime = getSliceTime(sliceCode); @@ -639,8 +619,6 @@ void PortfolioMode::runSlice(vstring sliceCode, int timeLimitInDeciseconds) */ void PortfolioMode::runSlice(Options& strategyOpt) { - CALL("PortfolioMode::runSlice(Option&)"); - System::registerForSIGHUPOnParentDeath(); UIHelper::portfolioParent=false; diff --git a/DP/ShortConflictMetaDP.cpp b/DP/ShortConflictMetaDP.cpp index c04965b68..de6603a72 100644 --- a/DP/ShortConflictMetaDP.cpp +++ b/DP/ShortConflictMetaDP.cpp @@ -24,7 +24,6 @@ namespace DP */ unsigned ShortConflictMetaDP::getCoreSize(const LiteralStack& core) { - CALL("ShortConflictMetaDP::getCoreSize"); // ASS_EQ(_solver.getStatus(), SATSolver::SATISFIABLE); unsigned res = 0; @@ -47,8 +46,6 @@ unsigned ShortConflictMetaDP::getCoreSize(const LiteralStack& core) */ DecisionProcedure::Status ShortConflictMetaDP::getStatus(bool getMultipleCores) { - CALL("ShortConflictMetaDP::getStatus"); - Status iStatus = _inner->getStatus(getMultipleCores); _unsatCores.reset(); @@ -109,7 +106,6 @@ DecisionProcedure::Status ShortConflictMetaDP::getStatus(bool getMultipleCores) */ void ShortConflictMetaDP::getUnsatCore(LiteralStack& res, unsigned coreIndex) { - CALL("ShortConflictMetaDP::getUnsatCore"); ASS(res.isEmpty()); ASS_L(coreIndex, _unsatCores.size()); diff --git a/DP/ShortConflictMetaDP.hpp b/DP/ShortConflictMetaDP.hpp index e274be939..caff1ae6e 100644 --- a/DP/ShortConflictMetaDP.hpp +++ b/DP/ShortConflictMetaDP.hpp @@ -44,12 +44,10 @@ class ShortConflictMetaDP : public DecisionProcedure { : _inner(inner), _sat2fo(sat2fo), _solver(solver) {} virtual void addLiterals(LiteralIterator lits, bool onlyEqualites) override { - CALL("ShortConflictMetaDP::addLiterals"); _inner->addLiterals(lits, onlyEqualites); } virtual void reset() override { - CALL("ShortConflictMetaDP::reset"); _inner->reset(); _unsatCores.reset(); } diff --git a/DP/SimpleCongruenceClosure.cpp b/DP/SimpleCongruenceClosure.cpp index 99b4230fc..ca1c2f659 100644 --- a/DP/SimpleCongruenceClosure.cpp +++ b/DP/SimpleCongruenceClosure.cpp @@ -35,8 +35,6 @@ const unsigned SimpleCongruenceClosure::NO_SIG_SYMBOL = 0xFFFFFFFF; vstring SimpleCongruenceClosure::CEq::toString() const { - CALL("SimpleCongruenceClosure::CEq::toString"); - vostringstream res; res << c1<<"="<::ConstIterator ulit(useList); while(ulit.hasNext()) { @@ -145,8 +135,6 @@ void SimpleCongruenceClosure::ConstInfo::assertValid(SimpleCongruenceClosure& pa SimpleCongruenceClosure::SimpleCongruenceClosure(Ordering* ord) : _ord(ord) { - CALL("SimpleCongruenceClosure::SimpleCongruenceClosure"); - _cInfos.ensure(1); //this ensures constants will start numbered from 1, not 0 _posLitConst = getFreshConst(); @@ -158,8 +146,6 @@ SimpleCongruenceClosure::SimpleCongruenceClosure(Ordering* ord) : void SimpleCongruenceClosure::reset() { - CALL("SimpleCongruenceClosure::reset"); - //do reset that keeps the data for converting terms to constants unsigned maxConst = getMaxConst(); for(unsigned i=1; i<=maxConst; i++) { @@ -195,8 +181,6 @@ void SimpleCongruenceClosure::reset() /** Introduce fresh congruence closure constant */ unsigned SimpleCongruenceClosure::getFreshConst() { - CALL("SimpleCongruenceClosure::getFreshConst"); - unsigned res = _cInfos.size(); _cInfos.expand(res+1); _cInfos[res].init(); @@ -206,8 +190,6 @@ unsigned SimpleCongruenceClosure::getFreshConst() /** Get congruence closure constant corresponding to a signature symbol number @c symbol */ unsigned SimpleCongruenceClosure::getSignatureConst(unsigned symbol, SignatureKind kind) { - CALL("SimpleCongruenceClosure::getSignatureConst"); - unsigned* pRes; if(!_sigConsts.getValuePtr(make_pair(symbol, kind), pRes)) { return *pRes; @@ -222,8 +204,6 @@ unsigned SimpleCongruenceClosure::getSignatureConst(unsigned symbol, SignatureKi unsigned SimpleCongruenceClosure::getPairName(CPair p) { - CALL("SimpleCongruenceClosure::getPairName"); - unsigned* pRes; if(!_pairNames.getValuePtr(p, pRes)) { return *pRes; @@ -258,8 +238,6 @@ struct SimpleCongruenceClosure::FOConversionWorker template void pre(TermList t, ChildCallback childCallbackFn) { - CALL("SimpleCongruenceClosure::FOConversionWorker::pre"); - if (t.isTerm()) { if(_parent._termNames.find(t)) { //term is in cache, we don't need to traverse it @@ -276,8 +254,6 @@ struct SimpleCongruenceClosure::FOConversionWorker unsigned post(TermList t, size_t childCnt, unsigned* childRes) { - CALL("SimpleCongruenceClosure::FOConversionWorker::post"); - unsigned res; if(_parent._termNames.find(t, res)) { return res; @@ -312,8 +288,6 @@ struct SimpleCongruenceClosure::FOConversionWorker */ unsigned SimpleCongruenceClosure::convertFO(TermList trm) { - CALL("SimpleCongruenceClosure::convertFO(TermList)"); - unsigned cachedRes; if(_termNames.find(trm, cachedRes)) { return cachedRes; @@ -330,7 +304,6 @@ unsigned SimpleCongruenceClosure::convertFO(TermList trm) */ unsigned SimpleCongruenceClosure::convertFONonEquality(Literal* lit) { - CALL("SimpleCongruenceClosure::convertFONonEquality"); ASS(!lit->isEquality()); unsigned res; @@ -363,8 +336,6 @@ unsigned SimpleCongruenceClosure::convertFONonEquality(Literal* lit) */ bool SimpleCongruenceClosure::isDistinctPred(Literal* l) { - CALL("SimpleCongruenceClosure::isDistinctPred"); - return Shell::DistinctProcessor::isDistinctPred(l); } @@ -373,8 +344,6 @@ bool SimpleCongruenceClosure::isDistinctPred(Literal* l) */ void SimpleCongruenceClosure::readDistinct(Literal* lit) { - CALL("SimpleCongruenceClosure::readDistinct"); - bool pos = lit->isPositive(); DistinctStack& tgtDStack = pos ? _distinctConstraints : _negDistinctConstraints; tgtDStack.push(DistinctEntry(lit)); @@ -393,7 +362,6 @@ void SimpleCongruenceClosure::readDistinct(Literal* lit) */ SimpleCongruenceClosure::CEq SimpleCongruenceClosure::convertFOEquality(Literal* equality) { - CALL("SimpleCongruenceClosure::convertFOEquality(Literal*)"); ASS(equality->isEquality()); unsigned arg1 = convertFO(*equality->nthArgument(0)); @@ -420,7 +388,6 @@ SimpleCongruenceClosure::CEq SimpleCongruenceClosure::convertFOEquality(Literal* */ void SimpleCongruenceClosure::addLiterals(LiteralIterator lits, bool onlyEqualites) { - CALL("SimpleCongruenceClosure::addLiterals"); ASS(!_hadPropagated); while(lits.hasNext()) { @@ -439,8 +406,6 @@ void SimpleCongruenceClosure::addLiterals(LiteralIterator lits, bool onlyEqualit void SimpleCongruenceClosure::addLiteral(Literal* lit) { - CALL("SimpleCongruenceClosure::addLiteral"); - if (lit->isEquality()) { CEq eq = convertFOEquality(lit); @@ -465,8 +430,6 @@ void SimpleCongruenceClosure::addLiteral(Literal* lit) } void SimpleCongruenceClosure::addPendingEquality(CEq eq) { - CALL("SimpleCongruenceClosure::addPendingEquality"); - ASS_G(eq.c1,0); ASS_G(eq.c2,0); _pendingEqualities.push_back(eq); @@ -477,8 +440,6 @@ void SimpleCongruenceClosure::addPendingEquality(CEq eq) { */ void SimpleCongruenceClosure::makeProofRepresentant(unsigned c) { - CALL("SimpleCongruenceClosure::makeProofRepresentant"); - if(_cInfos[c].proofPredecessor==0) { return; } @@ -507,8 +468,6 @@ void SimpleCongruenceClosure::makeProofRepresentant(unsigned c) */ void SimpleCongruenceClosure::propagate() { - CALL("SimpleCongruenceClosure::propagate"); - _hadPropagated = true; while(_pendingEqualities.isNonEmpty()) { @@ -581,8 +540,6 @@ void SimpleCongruenceClosure::propagate() bool SimpleCongruenceClosure::checkPositiveDistincts(bool retrieveMultipleCores) { - CALL("SimpleCongruenceClosure::checkPositiveDistincts"); - //map from a representative to constant in its class present in the current distinct group static ArrayMap reprs; reprs.ensure(getMaxConst()+1); @@ -655,8 +612,6 @@ DecisionProcedure::Status SimpleCongruenceClosure::checkNegativeDistincts(bool r */ DecisionProcedure::Status SimpleCongruenceClosure::getStatus(bool retrieveMultipleCores) { - CALL("SimpleCongruenceClosure::getStatus"); - // Propagate any pending equalities propagate(); @@ -713,8 +668,6 @@ DecisionProcedure::Status SimpleCongruenceClosure::getStatus(bool retrieveMultip */ unsigned SimpleCongruenceClosure::getProofDepth(unsigned c) { - CALL("SimpleCongruenceClosure::getProofDepth"); - unsigned res = 0; while(_cInfos[c].proofPredecessor!=0) { c = _cInfos[c].proofPredecessor; @@ -729,7 +682,6 @@ unsigned SimpleCongruenceClosure::getProofDepth(unsigned c) */ void SimpleCongruenceClosure::collectUnifyingPath(unsigned c1, unsigned c2, Stack& path) { - CALL("SimpleCongruenceClosure::collectUnifyingPath"); ASS_EQ(deref(c1), deref(c2)); //this function could be probably made more efficient if we use some time-stamping of the ConstInfo object @@ -777,7 +729,6 @@ void SimpleCongruenceClosure::collectUnifyingPath(unsigned c1, unsigned c2, Stac */ void SimpleCongruenceClosure::getUnsatCore(LiteralStack& res, unsigned coreIndex) { - CALL("SimpleCongruenceClosure::getUnsatCore"); ASS(res.isEmpty()); ASS_L(coreIndex,_unsatEqs.size()); @@ -890,8 +841,6 @@ struct SimpleCongruenceClosure::ConstOrderingComparator { */ void SimpleCongruenceClosure::computeConstsNormalForm(unsigned c, NFMap& normalForms) { - CALL("SimpleCongruenceClosure::computeConstsNormalForm"); - ConstInfo& cInfo = _cInfos[c]; if (!cInfo.term.isEmpty() && cInfo.normalForm.isEmpty()) { Term* t = cInfo.term.term(); @@ -926,8 +875,6 @@ void SimpleCongruenceClosure::computeConstsNormalForm(unsigned c, NFMap& normalF */ void SimpleCongruenceClosure::getModel(LiteralStack& model) { - CALL("SimpleCongruenceClosure::getModel"); - // a heap of candidate constants to process static DynamicHeap > candidates(ConstOrderingComparator(_cInfos,*_ord)); @@ -1096,7 +1043,6 @@ void SimpleCongruenceClosure::getModel(LiteralStack& model) #if VDEBUG void SimpleCongruenceClosure::assertModelInfoClean() const { - CALL("SimpleCongruenceClosure::assertModelInfoClean"); unsigned maxConst = getMaxConst(); for (unsigned c = 0; c <= maxConst; c++) { const ConstInfo& cInfo = _cInfos[c]; diff --git a/DP/SimpleCongruenceClosure.hpp b/DP/SimpleCongruenceClosure.hpp index a1dfa2b6b..4f9492b1e 100644 --- a/DP/SimpleCongruenceClosure.hpp +++ b/DP/SimpleCongruenceClosure.hpp @@ -140,7 +140,6 @@ class SimpleCongruenceClosure : public DecisionProcedure * i.e. the representative for its congruence class */ unsigned deref(unsigned c) const { - CALL("SimpleCongruenceClosure::deref"); unsigned repr = _cInfos[c].reprConst; unsigned res = (repr==0) ? c : repr; ASS_REP2(_cInfos[res].reprConst==0, _cInfos[res].reprConst, c); diff --git a/Debug/RuntimeStatistics.hpp b/Debug/RuntimeStatistics.hpp index 7b461718c..58a001712 100644 --- a/Debug/RuntimeStatistics.hpp +++ b/Debug/RuntimeStatistics.hpp @@ -55,8 +55,6 @@ To disable statistics collection from part of the code, add int main(int argc, char* argv []) { - CALL ("main"); - for(int i=0;i<100;i++) { if((i*i)%7==1) { RSTAT_CTR_INC("numbers with (i*i)%7==1"); diff --git a/Debug/Tracer.hpp b/Debug/Tracer.hpp index 8c75eb32f..cea21e19c 100644 --- a/Debug/Tracer.hpp +++ b/Debug/Tracer.hpp @@ -45,7 +45,7 @@ template struct _printDbg{ } }; -template void printDbg(const char* file, int line, const char *fun, const A&... msg) +template void printDbg(const char* file, int line, const A&... msg) { int width = 60; std::cout << "[ debug ] "; @@ -56,25 +56,14 @@ template void printDbg(const char* file, int line, const char *fun, std::cout << ' '; } std::cout << "@" << std::setw(5) << line << ":"; - - // TODO either use backtrace to figure out call depth or don't do this - /* - for (unsigned i = 0; i< _depth; i++) { - cout << " "; - } - */ - std::cout << fun << ": "; _printDbg{}(msg...); std::cout << std::endl; } } // namespace Debug -#define CALL(fun) -#define CALLC(fun, cond) - #if VDEBUG -# define DBG(...) { Debug::printDbg(__FILE__, __LINE__, __func__, __VA_ARGS__); } +# define DBG(...) { Debug::printDbg(__FILE__, __LINE__, __VA_ARGS__); } # define DBGE(x) DBG(#x, " = ", x) #else // ! VDEBUG # define DBG(...) {} diff --git a/FMB/ClauseFlattening.cpp b/FMB/ClauseFlattening.cpp index 4f272dddb..eb3f27b39 100644 --- a/FMB/ClauseFlattening.cpp +++ b/FMB/ClauseFlattening.cpp @@ -30,7 +30,6 @@ namespace FMB{ bool ClauseFlattening::isShallow(Literal* lit) { - CALL("ClauseFlattening::isShallow(Literal)"); // The term to check for variable arguments Term* check = 0; @@ -65,8 +64,6 @@ bool ClauseFlattening::isShallow(Literal* lit) */ Clause* ClauseFlattening::resolveNegativeVariableEqualities(Clause* cl) { - CALL("ClauseFlattening::resolveNegativeVariableEqualities"); - // a helper class to be passed to SubstHelper class SingleVar2VarSubst { unsigned _from; @@ -128,7 +125,6 @@ Clause* ClauseFlattening::resolveNegativeVariableEqualities(Clause* cl) */ Clause* ClauseFlattening::flatten(Clause* cl) { - CALL("ClauseFlattening::flatten"); TIME_TRACE("fmb flattening"); cl = resolveNegativeVariableEqualities(cl); diff --git a/FMB/CliqueFinder.hpp b/FMB/CliqueFinder.hpp index b1b93660b..032cb48ce 100644 --- a/FMB/CliqueFinder.hpp +++ b/FMB/CliqueFinder.hpp @@ -23,8 +23,6 @@ namespace FMB { public: static unsigned findMaxCliqueSize(DHMap*>* Ngraph) { - CALL("FMB::CliqueFinder::findMaxCliqueSize"); - //cout << "findMaxCliqueSize with " << Ngraph->size() << endl; // at least stores the number of nodes with at least index neighbours @@ -93,8 +91,6 @@ namespace FMB { // check if a clique is a clique static bool checkClique(DHMap*>* Ngraph, Stack& clique) { - CALL("FMB::CliqueFinder::checkClique"); - //cout << "CHECK "; for(unsigned j=0;jtoString() << endl; static Stack lits; // to rebuild the clause @@ -107,8 +103,6 @@ namespace FMB { } Term* addGroundDefinition(Term* term, Clause* from){ - CALL("DefinitionIntroduction::addGroundDefinition"); - //cout << "Adding defs for " << term->toString() << endl; ASS(term->ground()); if(term->arity()==0) return term; @@ -169,8 +163,6 @@ namespace FMB { /* Term* addNonGroundDefinition(Term* t, Clause* from){ - CALL("DefinitionIntroduction::addNonGroundDefinition"); - // currently don't do anything until I've fixed it return t; diff --git a/FMB/FiniteModel.cpp b/FMB/FiniteModel.cpp index e457557a3..7cbfe9ab4 100644 --- a/FMB/FiniteModel.cpp +++ b/FMB/FiniteModel.cpp @@ -46,8 +46,6 @@ using namespace Shell; FiniteModel::FiniteModel(unsigned size) : _size(size), _isPartial(false) { - CALL("FiniteModel::FiniteModel"); - (void)_isPartial; // to suppress unused warning f_offsets.ensure(env.signature->functions()); @@ -80,15 +78,12 @@ FiniteModel::FiniteModel(unsigned size) : _size(size), _isPartial(false) void FiniteModel::addConstantDefinition(unsigned f, unsigned res) { - CALL("FiniteModel::addConstantDefinition"); static const DArray empty(0); addFunctionDefinition(f,empty,res); } void FiniteModel::addFunctionDefinition(unsigned f, const DArray& args, unsigned res) { - CALL("FiniteModel::addFunctionDefinition"); - ASS_EQ(env.signature->functionArity(f),args.size()); unsigned var = f_offsets[f]; @@ -112,16 +107,12 @@ void FiniteModel::addFunctionDefinition(unsigned f, const DArray& args void FiniteModel::addPropositionalDefinition(unsigned p, bool res) { - CALL("FiniteModel::addPropositionalDefinition"); - static const DArray empty(0); addPredicateDefinition(p,empty,res); } void FiniteModel::addPredicateDefinition(unsigned p, const DArray& args, bool res) { - CALL("FiniteModel::addPredicateDefinition"); - ASS_EQ(env.signature->predicateArity(p),args.size()); unsigned var = p_offsets[p]; @@ -141,15 +132,12 @@ void FiniteModel::addPredicateDefinition(unsigned p, const DArray& arg bool FiniteModel::isPartial() { - CALL("FiniteModel::isPartial"); //TODO return true; } vstring FiniteModel::toString() { - CALL("FiniteModel::toString"); - vostringstream modelStm; bool printIntroduced = false; @@ -342,7 +330,6 @@ vstring FiniteModel::toString() unsigned FiniteModel::evaluateGroundTerm(Term* term) { - CALL("FiniteModel::evaluate(Term*)"); ASS(term->ground()); #if DEBUG_MODEL @@ -374,7 +361,6 @@ unsigned FiniteModel::evaluateGroundTerm(Term* term) bool FiniteModel::evaluateGroundLiteral(Literal* lit) { - CALL("FiniteModel::evaluate(Literal*)"); ASS(lit->ground()); #if DEBUG_MODEL @@ -427,8 +413,6 @@ bool FiniteModel::evaluateGroundLiteral(Literal* lit) bool FiniteModel::evaluate(Unit* unit) { - CALL("FiniteModel::evaluate(Unit*)"); - Formula* formula = 0; if(unit->isClause()){ Clause* clause = unit->asClause(); @@ -454,8 +438,6 @@ bool FiniteModel::evaluate(Unit* unit) */ bool FiniteModel::evaluate(Formula* formula,unsigned depth) { - CALL("FiniteModel::evaluate(Formula*)"); - #if DEBUG_MODEL for(unsigned i=0;itoString() << endl; @@ -568,8 +550,6 @@ bool FiniteModel::evaluate(Formula* formula,unsigned depth) */ Formula* FiniteModel::partialEvaluate(Formula* formula) { - CALL("FiniteModel::partialEvaluate(Formula*)"); - #if DEBUG_MODEL for(unsigned i=0;itoString() << endl; diff --git a/FMB/FiniteModelBuilder.cpp b/FMB/FiniteModelBuilder.cpp index 7cda3597e..f7dc2e768 100644 --- a/FMB/FiniteModelBuilder.cpp +++ b/FMB/FiniteModelBuilder.cpp @@ -75,8 +75,6 @@ FiniteModelBuilder::FiniteModelBuilder(Problem& prb, const Options& opt) _isAppropriate(true) { - CALL("FiniteModelBuilder::FiniteModelBuilder"); - Property& prop = *prb.getProperty(); LOG(prop.hasInterpretedOperations()); @@ -150,8 +148,6 @@ FiniteModelBuilder::FiniteModelBuilder(Problem& prb, const Options& opt) FiniteModelBuilder::~FiniteModelBuilder() { - CALL("FiniteModelBuilder::~FiniteModelBuilder"); - if(_dsaEnumerator){ BYPASSING_ALLOCATOR; @@ -163,8 +159,6 @@ FiniteModelBuilder::~FiniteModelBuilder() // Returns false we if we failed to reset, this can happen if offsets overflow 2^32, possible for // large signatures and large models. If this a frequent problem then we can go to longs. bool FiniteModelBuilder::reset(){ - CALL("FiniteModelBuilder::reset"); - // Construct the offsets for symbols // Each symbol requires size^n) variables where n is the number of spaces for grounding // For function symbols we have n=arity+1 as we have the return value @@ -324,8 +318,6 @@ struct FMBSymmetryFunctionComparator void FiniteModelBuilder::createSymmetryOrdering() { - CALL("FiniteModelBuilder::createSymmeteryOrdreing"); - // only really required the first time _sortedGroundedTerms.ensure(_sortedSignature->sorts); @@ -431,8 +423,6 @@ void FiniteModelBuilder::createSymmetryOrdering() // Initialise things for the first time void FiniteModelBuilder::init() { - CALL("FiniteModelBuilder::init"); - // If we're not complete don't both doing anything if(!_isAppropriate) return; @@ -957,8 +947,6 @@ void FiniteModelBuilder::init() void FiniteModelBuilder::addGroundClauses() { - CALL("FiniteModelBuilder::addGroundClauses"); - // If we don't have any ground clauses don't do anything if(!_groundClauses) return; @@ -990,7 +978,6 @@ void FiniteModelBuilder::addGroundClauses() // uses _distinctSortSizes to estimate how many instances would we generate unsigned FiniteModelBuilder::estimateInstanceCount() { - CALL("FiniteModelBuilder::estimateInstanceCount"); unsigned res = 0; ClauseList::Iterator cit(_clauses); @@ -1016,8 +1003,6 @@ unsigned FiniteModelBuilder::estimateInstanceCount() void FiniteModelBuilder::addNewInstances() { - CALL("FiniteModelBuilder::addNewInstances"); - ClauseList::Iterator cit(_clauses); while(cit.hasNext()){ @@ -1182,7 +1167,6 @@ void FiniteModelBuilder::addNewInstances() // uses _distinctSortSizes to estimate how many instances would we generate unsigned FiniteModelBuilder::estimateFunctionalDefCount() { - CALL("FiniteModelBuilder::estimateFunctionalDefCount"); unsigned res = 0; for(unsigned f=0;ffunctions();f++){ @@ -1211,8 +1195,6 @@ unsigned FiniteModelBuilder::estimateFunctionalDefCount() void FiniteModelBuilder::addNewFunctionalDefs() { - CALL("FiniteModelBuilder::addNewFunctionalDefs"); - // For each function f of arity n we add the constraint // f(x1,...,xn) != y | f(x1,...,xn) != z // they should be instantiated with groundings where y!=z @@ -1288,9 +1270,6 @@ void FiniteModelBuilder::addNewFunctionalDefs() void FiniteModelBuilder::addNewSymmetryOrderingAxioms(unsigned size, Stack& groundedTerms) { - CALL("FiniteModelBuilder::addNewSymmetryOrderingAxioms"); - - // Add restricted totality // i.e. for constant a1 add { a1=1 } and for a2 add { a2=1, a2=2 } and so on if(groundedTerms.length() < size) return; @@ -1320,8 +1299,6 @@ void FiniteModelBuilder::addNewSymmetryCanonicityAxioms(unsigned size, Stack& groundedTerms, unsigned maxSize) { - CALL("FiniteModelBuilder::addNewSymmetryCanonicityAxioms"); - if(size<=1) return; unsigned w = _symmetryRatio * maxSize; @@ -1364,8 +1341,6 @@ void FiniteModelBuilder::addNewSymmetryCanonicityAxioms(unsigned size, void FiniteModelBuilder::addUseModelSize(unsigned size) { - CALL("FiniteModelBuilder::addUseModelSize"); - return; /* @@ -1403,8 +1378,6 @@ void FiniteModelBuilder::addUseModelSize(unsigned size) void FiniteModelBuilder::addNewTotalityDefs() { - CALL("FiniteModelBuilder::addNewTotalityDefs"); - if (_xmass) { // make sure to solve the problem of some sorts not growing all the way to _sortModelSizes[srt], because of _sortedSignature->sortBounds[srt] for (unsigned i = 0; i < _distinctSortSizes.size(); i++) { @@ -1527,8 +1500,6 @@ void FiniteModelBuilder::addNewTotalityDefs() SATLiteral FiniteModelBuilder::getSATLiteral(unsigned f, const DArray& grounding, bool polarity,bool isFunction) { - CALL("FiniteModelBuilder::getSATLiteral"); - // cannot have predicate 0 here (it's equality) ASS(f>0 || isFunction); @@ -1562,7 +1533,6 @@ SATLiteral FiniteModelBuilder::getSATLiteral(unsigned f, const DArray& void FiniteModelBuilder::addSATClause(SATClause* cl) { - CALL("FiniteModelBuilder::addSATClause"); cl = SATClause::removeDuplicateLiterals(cl); if(!cl){ return; } #if VTRACE_FMB @@ -1575,8 +1545,6 @@ void FiniteModelBuilder::addSATClause(SATClause* cl) MainLoopResult FiniteModelBuilder::runImpl() { - CALL("FiniteModelBuilder::runImpl"); - if(!_isAppropriate){ // give up! return MainLoopResult(Statistics::INAPPROPRIATE); @@ -1919,7 +1887,6 @@ MainLoopResult FiniteModelBuilder::runImpl() void FiniteModelBuilder::onModelFound() { - CALL("FiniteModelBuilder::onModelFound"); // Don't do any output if proof is off if(_opt.proof()==Options::Proof::OFF){ return; @@ -2343,8 +2310,6 @@ void FiniteModelBuilder::onModelFound() void FiniteModelBuilder::HackyDSAE::learnNogood(Constraint_Generator_Vals& nogood, unsigned weight) { - CALL("FiniteModelBuilder::HackyDSAE::learnNogood"); - Constraint_Generator* constraint_p = new Constraint_Generator(nogood,weight); _constraints_generators.insert(constraint_p); @@ -2356,8 +2321,6 @@ void FiniteModelBuilder::HackyDSAE::learnNogood(Constraint_Generator_Vals& nogoo bool FiniteModelBuilder::HackyDSAE::checkConstriant(DArray& newSortSizes, Constraint_Generator_Vals& constraint) { - CALL("FiniteModelBuilder::HackyDSAE::checkConstriant"); - for (unsigned j = 0; j < newSortSizes.size(); j++) { pair& cc = constraint[j]; if (cc.first == EQ && cc.second != newSortSizes[j]) { @@ -2380,8 +2343,6 @@ bool FiniteModelBuilder::HackyDSAE::checkConstriant(DArray& newSortSiz bool FiniteModelBuilder::HackyDSAE::increaseModelSizes(DArray& newSortSizes, DArray& sortMaxes) { - CALL("FiniteModelBuilder::HackyDSAE::increaseModelSizes"); - // cout << "_constraints_generators.size() " << _constraints_generators.size() << endl; while (!_constraints_generators.isEmpty()) { @@ -2517,8 +2478,6 @@ bool FiniteModelBuilder::HackyDSAE::increaseModelSizes(DArray& newSort bool FiniteModelBuilder::SmtBasedDSAE::init(unsigned _startModelSize, DArray& _distinctSortSizes, Stack>& _distinct_sort_constraints, Stack>& _strict_distinct_sort_constraints) { - CALL("FiniteModelBuilder::SmtBasedDSAE::init"); - _skippedSomeSizes = (_startModelSize > 1); BYPASSING_ALLOCATOR; @@ -2570,8 +2529,6 @@ bool FiniteModelBuilder::SmtBasedDSAE::init(unsigned _startModelSize, DArray& szs) { - CALL("FiniteModelBuilder::SmtBasedDSAE::loadSizesFromSmt"); unsigned weight = 0; z3::model model = _smtSolver.get_model(); @@ -2622,8 +2578,6 @@ unsigned FiniteModelBuilder::SmtBasedDSAE::loadSizesFromSmt(DArray& sz void FiniteModelBuilder::SmtBasedDSAE::reportZ3OutOfMemory() { - CALL("FiniteModelBuilder::SmtBasedDSAE::reportZ3OutOfMemory"); - env.beginOutput(); reportSpiderStatus('m'); env.out() << "Z3 ran out of memory" << endl; @@ -2637,8 +2591,6 @@ void FiniteModelBuilder::SmtBasedDSAE::reportZ3OutOfMemory() bool FiniteModelBuilder::SmtBasedDSAE::increaseModelSizes(DArray& newSortSizes, DArray& sortMaxes) { - CALL("FiniteModelBuilder::SmtBasedDSAE::increaseModelSizes"); - BYPASSING_ALLOCATOR; try { diff --git a/FMB/FiniteModelMultiSorted.cpp b/FMB/FiniteModelMultiSorted.cpp index 2d7fe7d56..eec57e7bf 100644 --- a/FMB/FiniteModelMultiSorted.cpp +++ b/FMB/FiniteModelMultiSorted.cpp @@ -47,8 +47,6 @@ using namespace Shell; FiniteModelMultiSorted::FiniteModelMultiSorted(DHMap sizes) : _sizes(sizes), _isPartial(false) { - CALL("FiniteModelMultiSorted::FiniteModelMultiSorted"); - (void)_isPartial; // to suppress unused warning f_offsets.ensure(env.signature->functions()); @@ -106,15 +104,12 @@ FiniteModelMultiSorted::FiniteModelMultiSorted(DHMap sizes) : void FiniteModelMultiSorted::addConstantDefinition(unsigned f, unsigned res) { - CALL("FiniteModelMultiSorted::addConstantDefinition"); static const DArray empty(0); addFunctionDefinition(f,empty,res); } void FiniteModelMultiSorted::addFunctionDefinition(unsigned f, const DArray& args, unsigned res) { - CALL("FiniteModelMultiSorted::addFunctionDefinition"); - ASS_EQ(env.signature->functionArity(f),args.size()); if(env.signature->functionArity(f)==0 && !env.signature->getFunction(f)->introduced()){ @@ -150,16 +145,12 @@ void FiniteModelMultiSorted::addFunctionDefinition(unsigned f, const DArray empty(0); addPredicateDefinition(p,empty,res); } void FiniteModelMultiSorted::addPredicateDefinition(unsigned p, const DArray& args, bool res) { - CALL("FiniteModelMultiSorted::addPredicateDefinition"); - ASS_EQ(env.signature->predicateArity(p),args.size()); //cout << "addPredicateDefinition for " << p << "(" << env.signature->predicateName(p) << ")" << endl; @@ -183,15 +174,12 @@ void FiniteModelMultiSorted::addPredicateDefinition(unsigned p, const DArrayground()); #if DEBUG_MODEL @@ -490,7 +477,6 @@ unsigned FiniteModelMultiSorted::evaluateGroundTerm(Term* term) bool FiniteModelMultiSorted::evaluateGroundLiteral(Literal* lit) { - CALL("FiniteModelMultiSorted::evaluate(Literal*)"); ASS(lit->ground()); #if DEBUG_MODEL @@ -545,8 +531,6 @@ bool FiniteModelMultiSorted::evaluateGroundLiteral(Literal* lit) bool FiniteModelMultiSorted::evaluate(Unit* unit) { - CALL("FiniteModelMultiSorted::evaluate(Unit*)"); - Formula* formula = 0; if(unit->isClause()){ Clause* clause = unit->asClause(); @@ -572,8 +556,6 @@ bool FiniteModelMultiSorted::evaluate(Unit* unit) */ bool FiniteModelMultiSorted::evaluate(Formula* formula,unsigned depth) { - CALL("FiniteModelMultiSorted::evaluate(Formula*)"); - #if DEBUG_MODEL for(unsigned i=0;itoString() << endl; @@ -692,8 +674,6 @@ bool FiniteModelMultiSorted::evaluate(Formula* formula,unsigned depth) */ Formula* FiniteModelMultiSorted::partialEvaluate(Formula* formula) { - CALL("FiniteModelMultiSorted::partialEvaluate(Formula*)"); - #if DEBUG_MODEL for(unsigned i=0;itoString() << endl; diff --git a/FMB/FunctionRelationshipInference.cpp b/FMB/FunctionRelationshipInference.cpp index bad6f73ff..728a2c81b 100644 --- a/FMB/FunctionRelationshipInference.cpp +++ b/FMB/FunctionRelationshipInference.cpp @@ -55,7 +55,6 @@ void FunctionRelationshipInference::findFunctionRelationships(ClauseIterator cla DHSet>& nonstrict_cons, DHSet>& strict_cons) { - CALL("FunctionRelationshipInference::findFunctionRelationships"); bool print = env.options->showFMBsortInfo(); ClauseList* checkingClauses = getCheckingClauses(); @@ -201,8 +200,6 @@ void FunctionRelationshipInference::findFunctionRelationships(ClauseIterator cla ClauseList* FunctionRelationshipInference::getCheckingClauses() { - CALL("FunctionRelationshipInference::getCheckingClauses"); - ClauseList* newClauses = 0; unsigned initial_functions = env.signature->functions(); @@ -282,8 +279,6 @@ void FunctionRelationshipInference::addClaimForFunction(TermList x, TermList y, TermList arg_srt, TermList ret_srt, VList* existential, ClauseList*& newClauses) { - CALL("FunctionRelationshipInference::addClaimForFunction"); - VList* xy = VList::cons(0,VList::cons(1,VList::empty())); Formula* eq_fxfy = new AtomicFormula(Literal::createEquality(true,fx,fy,ret_srt)); @@ -322,8 +317,6 @@ void FunctionRelationshipInference::addClaimForFunction(TermList x, TermList y, void FunctionRelationshipInference::addClaim(Formula* conjecture, ClauseList*& newClauses) { - CALL("FunctionRelationshipInference::addClaim"); - FormulaUnit* fu = new FormulaUnit(conjecture, FromInput(UnitInputType::CONJECTURE)); //TODO create new Inference kind? @@ -343,8 +336,6 @@ void FunctionRelationshipInference::addClaim(Formula* conjecture, ClauseList*& n // get a name for a formula that captures the relationship that |fromSrt| >= |toSrt| Formula* FunctionRelationshipInference::getName(TermList fromSrt, TermList toSrt, bool strict) { - CALL("FunctionRelationshipInference::getName"); - unsigned label= env.signature->addFreshPredicate(0,"label"); env.signature->getPredicate(label)->markLabel(); diff --git a/FMB/ModelCheck.hpp b/FMB/ModelCheck.hpp index 7c9182514..8243ff70a 100644 --- a/FMB/ModelCheck.hpp +++ b/FMB/ModelCheck.hpp @@ -40,8 +40,6 @@ class ModelCheck{ public: static void doCheck(Problem*& prb) { - CALL("ModelCheck::doCheck"); - // find model size // looking for a domain axiom // Currently assume it is called 'finite_domain' @@ -165,8 +163,6 @@ static void doCheck(Problem*& prb) static void checkIsDomainLiteral(Literal* l, int& single_var, Set& domainConstants) { - CALL("ModelCheck::checkIsDomainLiteral"); - if(!l->isEquality()) USER_ERROR("finite_domain is not a domain axiom"); // put var in left and constant in right @@ -196,8 +192,6 @@ static void addDefinition(FiniteModel& model,Literal* lit,bool negated, Set& domainConstants, DHMap& domainConstantNumber) { - CALL("ModelCheck::addDefinition"); - if(lit->isEquality()){ if(!lit->polarity() || negated) USER_ERROR("Cannot have negated function definition"); // Defining a function or constant diff --git a/FMB/Monotonicity.cpp b/FMB/Monotonicity.cpp index 930340b1d..706daad8c 100644 --- a/FMB/Monotonicity.cpp +++ b/FMB/Monotonicity.cpp @@ -40,8 +40,6 @@ namespace FMB Monotonicity::Monotonicity(ClauseList* clauses, unsigned srt) : _srt(srt) { - CALL("Monotonicity::Monotonicity"); - _solver = new MinisatInterfacing(*env.options,true); // create pt and pf per predicate and add the constraint -pf | -pt @@ -73,8 +71,6 @@ Monotonicity::Monotonicity(ClauseList* clauses, unsigned srt) : _srt(srt) void Monotonicity::monotone(Clause* c, Literal* l) { - CALL("Monotonicity::monotone"); - // if we have equality if(l->isEquality()){ TermList* t1 = l->nthArgument(0); @@ -113,7 +109,6 @@ void Monotonicity::safe(Clause* c, Literal* parent, TermList* t,SATLiteral add){ void Monotonicity::safe(Clause* c, Literal* parent, TermList* t,Stack& slits) { - CALL("Monotonicity::safe"); if(t->isVar()){ unsigned var = t->var(); TermList s = SortHelper::getVariableSort(*t,parent); @@ -135,8 +130,6 @@ void Monotonicity::safe(Clause* c, Literal* parent, TermList* t,Stack& slits) { - CALL("Monotonicyt::guards"); - if(l->isEquality()){ // check for X != f(...) or f(...) != X // i.e. a negative equality with X on one side @@ -165,8 +158,6 @@ bool Monotonicity::guards(Literal* l, unsigned var, Stack& slits) void Monotonicity::addSortPredicates(bool withMon, ClauseList*& clauses, DArray& del_f) { - CALL("Monotonicity::addSortPredicates"); - // First compute the monotonic sorts DArray isMonotonic(env.signature->typeCons()); for(unsigned s=0;stypeCons();s++){ @@ -305,8 +296,6 @@ class SortFunctionTransformer { using Arg = TypedTermList; TermList operator()(TypedTermList origTerm, TermList *evalArgs) { - CALL("SortFunctionTransformer::transformSubterm"); - // cout << "transformSubterm " << trm.toString() << endl; TermList srt = origTerm.sort(); @@ -324,8 +313,6 @@ class SortFunctionTransformer { void Monotonicity::addSortFunctions(bool withMon, ClauseList*& clauses) { - CALL("Monotonicity::addSortFunctions"); - // First compute the monotonic sorts DArray isMonotonic(env.signature->typeCons()); for(unsigned s=0;stypeCons();s++){ diff --git a/FMB/SortInference.cpp b/FMB/SortInference.cpp index e7f95dc58..bfcfbc34b 100644 --- a/FMB/SortInference.cpp +++ b/FMB/SortInference.cpp @@ -49,7 +49,6 @@ namespace FMB */ void SortInference::doInference() { - CALL("SortInference::doInference"); bool _print = env.options->showFMBsortInfo(); if(_ignoreInference){ @@ -833,8 +832,6 @@ void SortInference::doInference() unsigned SortInference::getDistinctSort(unsigned subsort, unsigned realVampireSort, bool createNew) { - CALL("SortInference::getDistinctSort"); - static bool firstMonotonicSortSeen = false; static unsigned firstMonotonicSort = 0; static DHMap ourDistinctSorts; diff --git a/HACKING.md b/HACKING.md index 6dd4adb28..2619e6448 100644 --- a/HACKING.md +++ b/HACKING.md @@ -27,9 +27,6 @@ In a pinch, `git grep PAT` works OK too. * TODO something about each directory please (even if just "unused") ### Vampire idioms and quirks -* `CALL` macros at the start of most functions implement a call stack in debug mode, among other things (see `Debug/Tracer`). - Every non-trivial function (i.e. probably not getters/setters, but most other things) should do this: if you find one without it's a good first patch! - `CALL` is a no-op in release builds. * `ASS` and friends are debug-only assertions, defined in `Debug/Assertion`. No donkeys here. * Heavy use of "iterator" classes which can do slightly odd things. These are in the process of being re-organised somewhat by Joe. diff --git a/Indexing/AcyclicityIndex.cpp b/Indexing/AcyclicityIndex.cpp index 7e1281ffe..f2affcb96 100644 --- a/Indexing/AcyclicityIndex.cpp +++ b/Indexing/AcyclicityIndex.cpp @@ -31,8 +31,6 @@ namespace Indexing { unsigned CycleQueryResult::totalLengthClauses() { - CALL("CycleQueryResult::totalLengthClauses"); - unsigned n = 0; List::Iterator it(premises); while (it.hasNext()) { @@ -44,7 +42,6 @@ namespace Indexing void addSubterm(TermList t, List*& l) { - CALL("addSubterm"); List::Iterator it(l); while (it.hasNext()) { // TODO test for unifiability, keep only most general term @@ -57,8 +54,6 @@ namespace Indexing List* AcyclicityIndex::getSubterms(Term *t) { - CALL("AcyclicityIndex::getSubterms"); - Stack toVisit; List* res = List::empty(); @@ -95,8 +90,6 @@ namespace Indexing bool AcyclicityIndex::matchesPattern(Literal *lit, TermList *&fs, TermList *&t, TermList *sort) { - CALL("AcyclicityIndex::matchesPattern"); - if (!lit->isEquality() || !lit->polarity()) { return false; } @@ -209,8 +202,6 @@ namespace Indexing _nextAvailableIndex(0), _currentDepth(0) { - CALL("AcyclicityIndex::CycleSearchIterator"); - if (queryLit->isEquality()) { TermList sort = SortHelper::getEqualityArgumentSort(queryLit); @@ -234,8 +225,6 @@ namespace Indexing Clause *applySubstitution(Clause *c, unsigned index) { - CALL("AcyclicityIndex::applySubstitution"); - unsigned clen = c->length(); Clause* res = new(clen) Clause(clen, GeneratingInference1(InferenceRule::INSTANTIATION, c)); @@ -249,8 +238,6 @@ namespace Indexing CycleQueryResult *resultFromNode(CycleSearchTreeNode *node) { - CALL("AcyclicityIndex::CycleSearchIterator::resultFromNode"); - LiteralList* l = LiteralList::empty(); ClauseList* c = ClauseList::empty(); ClauseList* cTheta = ClauseList::empty(); @@ -276,8 +263,6 @@ namespace Indexing void pushUnificationsOnStack(TermList t, CycleSearchTreeNode *parent) { - CALL("Acyclicity::pushUnificationOnStack"); - ASS(t.isTerm()); ASS(_tis); TermQueryResultIterator tqrIt = _tis->getUnifications(TypedTermList(t.term())); @@ -303,8 +288,6 @@ namespace Indexing bool notInAncestors(CycleSearchTreeNode *node, Literal *l) { - CALL("AcyclicityIndex::CycleSearchIterator::notInAncestors"); - CycleSearchTreeNode *n = node; while (n) { if (n->lit == l) { @@ -318,8 +301,6 @@ namespace Indexing bool hasNext() { - CALL("AcyclicityIndex::CycleSearchIterator::hasNext"); - // if hasNext() has already been called without being followed // by a call to next(), the next value is already computed if (_nextResult) { return true; } @@ -380,8 +361,6 @@ namespace Indexing OWN_ELEMENT_TYPE next() { - CALL("AcyclicityIndex::CycleSearchIterator::next()"); - ASS(_nextResult); CycleQueryResult *res = _nextResult; _nextResult = nullptr; @@ -401,8 +380,6 @@ namespace Indexing void AcyclicityIndex::handleClause(Clause* c, bool adding) { - CALL("AcyclicityIndex::handleClause"); - ArrayishObjectIterator it = c->getSelectedLiteralIterator(); while (it.hasNext()) { if (adding) { @@ -415,8 +392,6 @@ namespace Indexing void AcyclicityIndex::insert(Literal *lit, Clause *c) { - CALL("AcyclicityIndex::insert"); - TermList *fs; TermList *t; TermList sort; @@ -443,8 +418,6 @@ namespace Indexing void AcyclicityIndex::remove(Literal *lit, Clause *c) { - CALL("AcyclicityIndex::remove"); - TermList *fs; TermList *t; TermList sort; @@ -461,8 +434,6 @@ namespace Indexing CycleQueryResultsIterator AcyclicityIndex::queryCycles(Literal *lit, Clause *c) { - CALL("AcyclicityIndex::queryCycle"); - return pvi(CycleSearchIterator(lit, c, *this)); } } diff --git a/Indexing/ClauseCodeTree.cpp b/Indexing/ClauseCodeTree.cpp index 1252a0bd6..febc72ced 100644 --- a/Indexing/ClauseCodeTree.cpp +++ b/Indexing/ClauseCodeTree.cpp @@ -42,8 +42,6 @@ using namespace Kernel; void ClauseCodeTree::onCodeOpDestroying(CodeOp* op) { - CALL("ClauseCodeTree::onCodeOpDestroying"); - if (op->isLitEnd()) { delete op->getILS(); } @@ -62,8 +60,6 @@ ClauseCodeTree::ClauseCodeTree() void ClauseCodeTree::insert(Clause* cl) { - CALL("ClauseCodeTree::insert"); - unsigned clen=cl->length(); static DArray lits; lits.initFromArray(clen, *cl); @@ -100,8 +96,6 @@ struct ClauseCodeTree::InitialLiteralOrderingComparator void ClauseCodeTree::optimizeLiteralOrder(DArray& lits) { - CALL("ClauseCodeTree::optimizeLiteralOrder"); - unsigned clen=lits.size(); if(isEmpty() || clen<=1) { return; @@ -153,8 +147,6 @@ void ClauseCodeTree::optimizeLiteralOrder(DArray& lits) void ClauseCodeTree::evalSharing(Literal* lit, CodeOp* startOp, size_t& sharedLen, size_t& unsharedLen, CodeOp*& nextOp) { - CALL("ClauseCodeTree::evalSharing"); - static CodeStack code; static CompileContext cctx; @@ -184,8 +176,6 @@ void ClauseCodeTree::evalSharing(Literal* lit, CodeOp* startOp, size_t& sharedLe */ void ClauseCodeTree::matchCode(CodeStack& code, CodeOp* startOp, size_t& matchedCnt, CodeOp*& nextOp) { - CALL("ClauseCodeTree::matchCode"); - size_t clen=code.length(); CodeOp* treeOp=startOp; @@ -230,8 +220,6 @@ void ClauseCodeTree::matchCode(CodeStack& code, CodeOp* startOp, size_t& matched void ClauseCodeTree::remove(Clause* cl) { - CALL("ClauseCodeTree::remove"); - static DArray lInfos; Recycled> firstsInBlocks; Recycled>> rlms; @@ -309,8 +297,6 @@ void ClauseCodeTree::remove(Clause* cl) void ClauseCodeTree::RemovingLiteralMatcher::init(CodeOp* entry_, LitInfo* linfos_, size_t linfoCnt_, ClauseCodeTree* tree_, Stack* firstsInBlocks_) { - CALL("ClauseCodeTree::RemovingLiteralMatcher::init"); - RemovingMatcher::init(entry_, linfos_, linfoCnt_, tree_, firstsInBlocks_); ALWAYS(prepareLiteral()); @@ -322,8 +308,6 @@ void ClauseCodeTree::RemovingLiteralMatcher::init(CodeOp* entry_, LitInfo* linfo */ bool ClauseCodeTree::removeOneOfAlternatives(CodeOp* op, Clause* cl, Stack* firstsInBlocks) { - CALL("ClauseCodeTree::removeOneOfAlternatives"); - unsigned initDepth=firstsInBlocks->size(); while(!op->isSuccess() || op->getSuccessResult()!=cl) { @@ -351,7 +335,6 @@ void ClauseCodeTree::LiteralMatcher::init(CodeTree* tree_, CodeOp* entry_, LitInfo* linfos_, size_t linfoCnt_, bool seekOnlySuccess) { - CALL("ClauseCodeTree::LiteralMatcher::init"); ASS_G(linfoCnt_,0); Matcher::init(tree_,entry_); @@ -388,8 +371,6 @@ void ClauseCodeTree::LiteralMatcher::init(CodeTree* tree_, CodeOp* entry_, */ bool ClauseCodeTree::LiteralMatcher::next() { - CALL("ClauseCodeTree::LiteralMatcher::next"); - if(eagerlyMatched()) { _matched=!eagerResults.isEmpty(); if(!_matched) { @@ -421,7 +402,6 @@ bool ClauseCodeTree::LiteralMatcher::next() */ bool ClauseCodeTree::LiteralMatcher::doEagerMatching() { - CALL("ClauseCodeTree::LiteralMatcher::doEagerMatching"); ASS(!eagerlyMatched()); //eager matching can be done only once ASS(eagerResults.isEmpty()); ASS(!finished()); @@ -466,7 +446,6 @@ bool ClauseCodeTree::LiteralMatcher::doEagerMatching() void ClauseCodeTree::LiteralMatcher::recordMatch() { - CALL("ClauseCodeTree::LiteralMatcher::recordMatch"); ASS(matched()); ILStruct* ils=op->getILS(); @@ -492,7 +471,6 @@ void ClauseCodeTree::LiteralMatcher::recordMatch() */ void ClauseCodeTree::ClauseMatcher::init(ClauseCodeTree* tree_, Clause* query_, bool sres_) { - CALL("ClauseCodeTree::ClauseMatcher::init"); ASS(!tree_->isEmpty()); query=query_; @@ -559,8 +537,6 @@ void ClauseCodeTree::ClauseMatcher::init(ClauseCodeTree* tree_, Clause* query_, void ClauseCodeTree::ClauseMatcher::reset() { - CALL("ClauseCodeTree::ClauseMatcher::deinit"); - unsigned liCnt=lInfos.size(); for(unsigned i=0;iisLitEnd()); ASS_EQ(lms.top()->op, op); @@ -700,8 +673,6 @@ inline bool ClauseCodeTree::ClauseMatcher::canEnterLiteral(CodeOp* op) */ void ClauseCodeTree::ClauseMatcher::enterLiteral(CodeOp* entry, bool seekOnlySuccess) { - CALL("ClauseCodeTree::ClauseMatcher::enterLiteral"); - if(!seekOnlySuccess) { RSTAT_MCTR_INC("enterLiteral levels (non-sos)", lms.size()); } @@ -733,7 +704,6 @@ void ClauseCodeTree::ClauseMatcher::enterLiteral(CodeOp* entry, bool seekOnlySuc void ClauseCodeTree::ClauseMatcher::leaveLiteral() { - CALL("ClauseCodeTree::ClauseMatcher::leaveLiteral"); ASS(lms.isNonEmpty()); lms.pop(); @@ -762,8 +732,6 @@ void ClauseCodeTree::ClauseMatcher::leaveLiteral() bool ClauseCodeTree::ClauseMatcher::checkCandidate(Clause* cl, int& resolvedQueryLit) { - CALL("ClauseCodeTree::ClauseMatcher::checkCandidate"); - unsigned clen=cl->length(); //the last matcher in mls is the one that yielded the SUCCESS operation ASS_EQ(clen, lms.size()-1); @@ -819,8 +787,6 @@ bool ClauseCodeTree::ClauseMatcher::checkCandidate(Clause* cl, int& resolvedQuer bool ClauseCodeTree::ClauseMatcher::matchGlobalVars(int& resolvedQueryLit) { - CALL("ClauseCodeTree::ClauseMatcher::matchGlobalVars"); - //TODO: perform _set_, not _multiset_ subsumption for subsumption resolution // bool verbose=query->number()==58746; @@ -918,8 +884,6 @@ bool ClauseCodeTree::ClauseMatcher::matchGlobalVars(int& resolvedQueryLit) bool ClauseCodeTree::ClauseMatcher::compatible(ILStruct* bi, MatchInfo* bq, ILStruct* ni, MatchInfo* nq) { - CALL("ClauseCodeTree::ClauseMatcher::compatible"); - if( lInfos[bq->liIndex].litIndex==lInfos[nq->liIndex].litIndex || (lInfos[bq->liIndex].opposite && lInfos[nq->liIndex].opposite) ) { return false; @@ -965,8 +929,6 @@ bool ClauseCodeTree::ClauseMatcher::compatible(ILStruct* bi, MatchInfo* bq, ILSt bool ClauseCodeTree::ClauseMatcher::existsCompatibleMatch(ILStruct* si, MatchInfo* sq, ILStruct* targets) { - CALL("ClauseCodeTree::ClauseMatcher::existsCompatibleMatch"); - size_t tcnt=targets->matchCnt; for(size_t i=0;igetMatch(i))) { diff --git a/Indexing/ClauseVariantIndex.cpp b/Indexing/ClauseVariantIndex.cpp index 7cbbba951..539f29bfb 100644 --- a/Indexing/ClauseVariantIndex.cpp +++ b/Indexing/ClauseVariantIndex.cpp @@ -113,8 +113,6 @@ class SubstitutionTreeClauseVariantIndex::SLQueryResultToClauseFn ClauseIterator SubstitutionTreeClauseVariantIndex::retrieveVariants(Literal* const * lits, unsigned length) { - CALL("SubstitutionTreeClauseVariantIndex::retrieveVariants/2"); - if(length==0) { return pvi( ClauseList::Iterator(_emptyClauses) ); } @@ -147,8 +145,6 @@ ClauseIterator SubstitutionTreeClauseVariantIndex::retrieveVariants(Literal* con SubstitutionTreeClauseVariantIndex::~SubstitutionTreeClauseVariantIndex() { - CALL("SubstitutionTreeClauseVariantIndex::~SubstitutionTreeClauseVariantIndex"); - unsigned streeArrSz=_strees.size(); for(unsigned i=0;ilength(); if(cl->length()==0) { @@ -195,7 +189,6 @@ void SubstitutionTreeClauseVariantIndex::insert(Clause* cl) Literal* SubstitutionTreeClauseVariantIndex::getMainLiteral(Literal* const * lits, unsigned length) { - CALL("SubstitutionTreeClauseVariantIndex::getMainLiteral"); ASS_G(length,0); static LiteralComparators::NormalizedLinearComparatorByWeight<> comp; @@ -218,8 +211,6 @@ Literal* SubstitutionTreeClauseVariantIndex::getMainLiteral(Literal* const * lit HashingClauseVariantIndex::~HashingClauseVariantIndex() { - CALL("HashingClauseVariantIndex::~HashingClauseVariantIndex"); - /* unsigned max = 0; ClauseList* maxval = 0; @@ -254,8 +245,6 @@ HashingClauseVariantIndex::~HashingClauseVariantIndex() void HashingClauseVariantIndex::insert(Clause* cl) { - CALL("HashingClauseVariantIndex::insert"); - TIME_TRACE("hvci insert"); // static unsigned insertions = 0; @@ -276,8 +265,6 @@ void HashingClauseVariantIndex::insert(Clause* cl) ClauseIterator HashingClauseVariantIndex::retrieveVariants(Literal* const * lits, unsigned length) { - CALL("HashingClauseVariantIndex::retrieveVariants/2"); - TIME_TRACE("hvci retrieve"); unsigned h = computeHash(lits,length); @@ -304,8 +291,6 @@ struct HashingClauseVariantIndex::VariableIgnoringComparator { static Comparison disagreement(Term* t1,Term* t2) { - CALL("HashingClauseVariantIndex::VariableIgnoringComparator::disagreement"); - //now get just some total deterministic order while ignoring variables static DisagreementSetIterator dsit; dsit.reset(t1, t2, false); @@ -329,8 +314,6 @@ struct HashingClauseVariantIndex::VariableIgnoringComparator { static Comparison compare(TermList* tl1, TermList* tl2) { - CALL("HashingClauseVariantIndex::VariableIgnoringComparator::compare(Termlist*,Termlist*)"); - if(!tl1->isTerm()) { if(!tl2->isTerm()) { return EQUAL; @@ -369,8 +352,6 @@ struct HashingClauseVariantIndex::VariableIgnoringComparator { static Comparison compare(Literal* l1, Literal* l2) { - CALL("HashingClauseVariantIndex::VariableIgnoringComparator::compare(Literal*,Literal*)"); - if(l1->weight()!=l2->weight()) { // number of general symbol occurrences return Int::compare(l1->weight(),l2->weight()); @@ -420,8 +401,6 @@ struct HashingClauseVariantIndex::VariableIgnoringComparator { * A total ordering stable under variable substitutions. */ bool operator()(unsigned a, unsigned b) { - CALL("HashingClauseVariantIndex::VariableIgnoringComparator::operator()"); - // cout << "a = " << a << " lits[a]= " << _lits[a] << endl; // cout << "b = " << b << " lits[b]= " << _lits[b] << endl; @@ -436,8 +415,6 @@ struct HashingClauseVariantIndex::VariableIgnoringComparator { }; unsigned HashingClauseVariantIndex::computeHashAndCountVariables(TermList* ptl, VarCounts& varCnts, unsigned hash_begin) { - CALL("HashingClauseVariantIndex::computeHashAndCountVariables(Term*, ...)"); - if (ptl->isVar()) { return computeHashAndCountVariables(ptl->var(),varCnts,hash_begin); } @@ -467,8 +444,6 @@ unsigned HashingClauseVariantIndex::computeHashAndCountVariables(TermList* ptl, } unsigned HashingClauseVariantIndex::computeHashAndCountVariables(Literal* l, VarCounts& varCnts, unsigned hash_begin) { - CALL("HashingClauseVariantIndex::computeHashAndCountVariables(Literal*, ...)"); - //cout << "Literal " << l->toString() << endl; if (l->ground()) { @@ -504,8 +479,6 @@ unsigned HashingClauseVariantIndex::computeHashAndCountVariables(Literal* l, Var unsigned HashingClauseVariantIndex::computeHash(Literal* const * lits, unsigned length) { - CALL("HashingClauseVariantIndex::computeHash"); - // cout << "length " << length << endl; TIME_TRACE("hvci compute hash"); diff --git a/Indexing/ClauseVariantIndex.hpp b/Indexing/ClauseVariantIndex.hpp index 4cb6f45ae..f395b7b7c 100644 --- a/Indexing/ClauseVariantIndex.hpp +++ b/Indexing/ClauseVariantIndex.hpp @@ -40,8 +40,6 @@ class ClauseVariantIndex virtual ClauseIterator retrieveVariants(Literal* const * lits, unsigned length) = 0; ClauseIterator retrieveVariants(Clause* cl) { - CALL("ClauseVariantIndex::retrieveVariants/1"); - // cout << "retrieveVariants for " << cl->toString() << endl; return retrieveVariants(cl->literals(), cl->length()); diff --git a/Indexing/CodeTree.cpp b/Indexing/CodeTree.cpp index 9f89b91b4..25491d0c0 100644 --- a/Indexing/CodeTree.cpp +++ b/Indexing/CodeTree.cpp @@ -43,8 +43,6 @@ using namespace Kernel; CodeTree::LitInfo::LitInfo(Clause* cl, unsigned litIndex) : litIndex(litIndex), opposite(false) { - CALL("CodeTree::LitInfo::LitInfo"); - ft=FlatTerm::create((*cl)[litIndex]); } @@ -90,8 +88,6 @@ CodeTree::LitInfo CodeTree::LitInfo::getOpposite(const LitInfo& li) */ CodeTree::MatchInfo* CodeTree::MatchInfo::alloc(unsigned bindCnt) { - CALL("MatchInfo::alloc"); - //We have to get sizeof(MatchInfo) + (bindCnt-1)*sizeof(TermList) //this way, because bindCnt-1 wouldn't behave well for //bindCnt==0 on x64 platform. @@ -107,8 +103,6 @@ CodeTree::MatchInfo* CodeTree::MatchInfo::alloc(unsigned bindCnt) */ void CodeTree::MatchInfo::destroy(unsigned bindCnt) { - CALL("MatchInfo::destroy"); - //We have to get sizeof(MatchInfo) + (bindCnt-1)*sizeof(TermList) //this way, because bindCnt-1 wouldn't behave well for //bindCnt==0 on x64 platform. @@ -202,8 +196,6 @@ struct CodeTree::ILStruct::GVArrComparator */ void CodeTree::ILStruct::putIntoSequence(ILStruct* previous_) { - CALL("CodeTree::ILStruct::putIntoSequence"); - previous=previous_; depth=previous ? (previous->depth+1) : 0; @@ -231,8 +223,6 @@ void CodeTree::ILStruct::putIntoSequence(ILStruct* previous_) bool CodeTree::ILStruct::equalsForOpMatching(const ILStruct& o) const { - CALL("CodeTree::ILStruct::equalsForOpMatching"); - //LIT_END is always at the end of the term and we ask for op matching only //if the prefixes were equal. In this case the number of variables and the fact //the literal is an equality between variables should be the same on both literals. @@ -250,8 +240,6 @@ bool CodeTree::ILStruct::equalsForOpMatching(const ILStruct& o) const void CodeTree::ILStruct::ensureFreshness(unsigned globalTimestamp) { - CALL("CodeTree::ILStruct::ensureFreshness"); - if(timestamp!=globalTimestamp) { timestamp=globalTimestamp; visited=false; @@ -263,8 +251,6 @@ void CodeTree::ILStruct::ensureFreshness(unsigned globalTimestamp) void CodeTree::ILStruct::addMatch(unsigned liIndex, DArray& bindingArray) { - CALL("CodeTree::ILStruct::addMatch"); - if(matchCnt==matches.size()) { matches.expand(matchCnt ? (matchCnt*2) : 4); size_t newSize=matches.size(); @@ -290,7 +276,6 @@ void CodeTree::ILStruct::addMatch(unsigned liIndex, DArray& bindingArr */ void CodeTree::ILStruct::deleteMatch(unsigned matchIndex) { - CALL("CodeTree::ILStruct::deleteMatch"); ASS_L(matchIndex, matchCnt); matchCnt--; @@ -299,7 +284,6 @@ void CodeTree::ILStruct::deleteMatch(unsigned matchIndex) CodeTree::MatchInfo*& CodeTree::ILStruct::getMatch(unsigned matchIndex) { - CALL("CodeTree::ILStruct::getMatch"); ASS(!finished); ASS_L(matchIndex, matchCnt); ASS(matches[matchIndex]); @@ -309,7 +293,6 @@ CodeTree::MatchInfo*& CodeTree::ILStruct::getMatch(unsigned matchIndex) CodeTree::CodeOp CodeTree::CodeOp::getSuccess(void* ptr) { - CALL("CodeTree::CodeOp::getSuccess"); ASS(ptr); //data has to be a non-zero pointer CodeOp res; @@ -320,8 +303,6 @@ CodeTree::CodeOp CodeTree::CodeOp::getSuccess(void* ptr) } CodeTree::CodeOp CodeTree::CodeOp::getLitEnd(ILStruct* ils) { - CALL("CodeTree::CodeOp::getLitEnd"); - CodeOp res; res.setAlternative(0); res._data=reinterpret_cast(ils)|LIT_END; @@ -330,7 +311,6 @@ CodeTree::CodeOp CodeTree::CodeOp::getLitEnd(ILStruct* ils) } CodeTree::CodeOp CodeTree::CodeOp::getTermOp(InstructionSuffix i, unsigned num) { - CALL("CodeTree::CodeOp::getTermOp"); ASS(i==CHECK_FUN || i==CHECK_VAR || i==ASSIGN_VAR); CodeOp res; @@ -342,7 +322,6 @@ CodeTree::CodeOp CodeTree::CodeOp::getTermOp(InstructionSuffix i, unsigned num) CodeTree::CodeOp CodeTree::CodeOp::getGroundTermCheck(Term* trm) { - CALL("CodeTree::CodeOp::getGroundTermCheck"); ASS(trm->ground()); CodeOp res; @@ -358,8 +337,6 @@ CodeTree::CodeOp CodeTree::CodeOp::getGroundTermCheck(Term* trm) */ bool CodeTree::CodeOp::equalsForOpMatching(const CodeOp& o) const { - CALL("CodeTree::CodeOp::equalsForOpMatching"); - if(instrPrefix()!=o.instrPrefix()) { return false; } @@ -381,8 +358,6 @@ bool CodeTree::CodeOp::equalsForOpMatching(const CodeOp& o) const CodeTree::SearchStruct* CodeTree::CodeOp::getSearchStruct() { - CALL("CodeTree::CodeOp::getSearchStruct"); - //the following line gives warning for not being according //to the standard, so we have to work around // static const size_t opOfs=offsetof(SearchStruct,landingOp); @@ -398,16 +373,12 @@ CodeTree::SearchStruct* CodeTree::CodeOp::getSearchStruct() CodeTree::SearchStruct::SearchStruct(Kind kind) : kind(kind) { - CALL("CodeTree::SearchStruct::SearchStruct"); - landingOp.setAlternative(0); landingOp.setLongInstr(SEARCH_STRUCT); } void CodeTree::SearchStruct::destroy() { - CALL("CodeTree::SearchStruct::destroy"); - switch(kind) { case FN_STRUCT: delete static_cast(this); @@ -420,8 +391,6 @@ void CodeTree::SearchStruct::destroy() bool CodeTree::SearchStruct::getTargetOpPtr(const CodeOp& insertedOp, CodeOp**& tgt) { - CALL("CodeTree::SearchStruct::getTargetOpPtr(const CodeOp&...)"); - switch(kind) { case FN_STRUCT: if(!insertedOp.isCheckFun()) { return false; } @@ -438,8 +407,6 @@ bool CodeTree::SearchStruct::getTargetOpPtr(const CodeOp& insertedOp, CodeOp**& CodeTree::CodeOp* CodeTree::SearchStruct::getTargetOp(const FlatTerm::Entry* ftPos) { - CALL("CodeTree::SearchStruct::getTargetOp"); - if(!ftPos->isFun()) { return 0; } switch(kind) { case FN_STRUCT: @@ -456,7 +423,6 @@ CodeTree::CodeOp* CodeTree::SearchStruct::getTargetOp(const FlatTerm::Entry* ftP CodeTree::FixedSearchStruct::FixedSearchStruct(Kind kind, size_t length) : SearchStruct(kind), length(length) { - CALL("CodeTree::FixedSearchStruct::FixedSearchStruct"); ASS(length); size_t tgtSize=sizeof(CodeOp*)*length; @@ -466,8 +432,6 @@ CodeTree::FixedSearchStruct::FixedSearchStruct(Kind kind, size_t length) CodeTree::FixedSearchStruct::~FixedSearchStruct() { - CALL("CodeTree::FixedSearchStruct::~FixedSearchStruct"); - size_t tgtSize=sizeof(CodeOp*)*length; DEALLOC_KNOWN(targets, tgtSize, "CodeTree::FixedSearchStruct::targets"); } @@ -475,7 +439,6 @@ CodeTree::FixedSearchStruct::~FixedSearchStruct() CodeTree::GroundTermSearchStruct::GroundTermSearchStruct(size_t length) : FixedSearchStruct(GROUND_TERM_STRUCT, length) { - CALL("CodeTree::GroundTermSearchStruct::GroundTermSearchStruct"); ASS(length); size_t valSize=sizeof(Term*)*length; @@ -485,16 +448,12 @@ CodeTree::GroundTermSearchStruct::GroundTermSearchStruct(size_t length) CodeTree::GroundTermSearchStruct::~GroundTermSearchStruct() { - CALL("CodeTree::GroundTermSearchStruct::~GroundTermSearchStruct"); - size_t valSize=sizeof(Term*)*length; DEALLOC_KNOWN(values, valSize, "CodeTree::GroundTermSearchStruct::values"); } CodeTree::CodeOp*& CodeTree::GroundTermSearchStruct::targetOp(const Term* trm) { - CALL("CodeTree::GroundTermSearchStruct::findTargetOp"); - size_t left=0; size_t right=length-1; while(left top_ops; // each top_op is either a first op of a Block or a SearchStruct // but it cannot be both since SearchStructs don't occur inside blocks @@ -673,7 +625,6 @@ CodeTree::~CodeTree() */ CodeTree::CodeBlock* CodeTree::firstOpToCodeBlock(CodeOp* op) { - CALL("CodeTree::firstOpToCodeBlock"); ASS(!op->isSearchStruct()); //the following line gives warning for not being according @@ -692,8 +643,6 @@ CodeTree::CodeBlock* CodeTree::firstOpToCodeBlock(CodeOp* op) template void CodeTree::visitAllOps(Visitor visitor) { - CALL("CodeTree::visitAllOps"); - static Stack top_ops; // each top_op is either a first op of a Block or a SearchStruct // but it cannot be both since SearchStructs don't occur inside blocks @@ -737,8 +686,6 @@ void CodeTree::visitAllOps(Visitor visitor) void CodeTree::CompileContext::init() { - CALL("CodeTree::CompileContext::init"); - nextVarNum=0; varMap.reset(); nextGlobalVarNum=0; @@ -747,16 +694,12 @@ void CodeTree::CompileContext::init() void CodeTree::CompileContext::nextLit() { - CALL("CodeTree::CompileContext::nextLit"); - nextVarNum=0; varMap.reset(); } void CodeTree::CompileContext::deinit(CodeTree* tree, bool discarded) { - CALL("CodeTree::CompileContext::deinit"); - if(discarded) { return; } @@ -772,8 +715,6 @@ void CodeTree::CompileContext::deinit(CodeTree* tree, bool discarded) void CodeTree::compileTerm(Term* trm, CodeStack& code, CompileContext& cctx, bool addLitEnd) { - CALL("CodeTree::compileTerm"); - static Stack globalCounterparts; globalCounterparts.reset(); @@ -847,8 +788,6 @@ void CodeTree::compileTerm(Term* trm, CodeStack& code, CompileContext& cctx, boo */ CodeTree::CodeBlock* CodeTree::buildBlock(CodeStack& code, size_t cnt, ILStruct* prev) { - CALL("CodeTree::buildBlock"); - size_t clen=code.length(); ASS_LE(cnt,clen); @@ -873,7 +812,6 @@ CodeTree::CodeBlock* CodeTree::buildBlock(CodeStack& code, size_t cnt, ILStruct* */ void CodeTree::incorporate(CodeStack& code) { - CALL("CodeTree::incorporate"); ASS(code.top().isSuccess()); if(isEmpty()) { @@ -1003,7 +941,6 @@ void CodeTree::incorporate(CodeStack& code) void CodeTree::compressCheckOps(CodeOp* chainStart, SearchStruct::Kind kind) { - CALL("CodeTree::compressCheckOps"); ASS(chainStart->alternative()); static Stack toDo; @@ -1085,7 +1022,6 @@ void CodeTree::compressCheckOps(CodeOp* chainStart, SearchStruct::Kind kind) void CodeTree::optimizeMemoryAfterRemoval(Stack* firstsInBlocks, CodeOp* removedOp) { - CALL("CodeTree::optimizeMemoryAfterRemoval"); ASS(removedOp->isFail()); LOG_OP("Code tree removal memory optimization"); LOG_OP("firstsInBlocks->size()="<size()); @@ -1225,8 +1161,6 @@ void CodeTree::optimizeMemoryAfterRemoval(Stack* firstsInBlocks, CodeOp void CodeTree::RemovingMatcher::init(CodeOp* entry_, LitInfo* linfos_, size_t linfoCnt_, CodeTree* tree_, Stack* firstsInBlocks_) { - CALL("CodeTree::RemovingMatcher::init"); - fresh=true; entry=entry_; linfos=linfos_; @@ -1245,8 +1179,6 @@ void CodeTree::RemovingMatcher::init(CodeOp* entry_, LitInfo* linfos_, bool CodeTree::RemovingMatcher::next() { - CALL("CodeTree::RemovingMatcher::next"); - if(fresh) { fresh=false; } @@ -1327,8 +1259,6 @@ bool CodeTree::RemovingMatcher::next() bool CodeTree::RemovingMatcher::backtrack() { - CALL("CodeTree::RemovingMatcher::backtrack"); - if(btStack.isEmpty()) { curLInfo++; return prepareLiteral(); @@ -1343,8 +1273,6 @@ bool CodeTree::RemovingMatcher::backtrack() bool CodeTree::RemovingMatcher::prepareLiteral() { - CALL("CodeTree::RemovingMatcher::prepareLiteral"); - firstsInBlocks->truncate(initFIBDepth); if(curLInfo>=linfoCnt) { return false; @@ -1357,7 +1285,6 @@ bool CodeTree::RemovingMatcher::prepareLiteral() inline bool CodeTree::RemovingMatcher::doSearchStruct() { - CALL("CodeTree::RemovingMatcher::doSearchStruct"); ASS_EQ(op->instrSuffix(), SEARCH_STRUCT); const FlatTerm::Entry* fte=&(*ft)[tp]; @@ -1427,8 +1354,6 @@ void CodeTree::incTimeStamp() void CodeTree::Matcher::init(CodeTree* tree_, CodeOp* entry_) { - CALL("CodeTree::Matcher::init"); - tree=tree_; entry=entry_; @@ -1441,8 +1366,6 @@ void CodeTree::Matcher::init(CodeTree* tree_, CodeOp* entry_) bool CodeTree::Matcher::execute() { - CALL("CodeTree::Matcher::execute"); - if(_fresh) { _fresh=false; } @@ -1540,8 +1463,6 @@ bool CodeTree::Matcher::backtrack() bool CodeTree::Matcher::prepareLiteral() { - CALL("CodeTree::Matcher::prepareLiteral"); - if(curLInfo>=linfoCnt) { return false; } diff --git a/Indexing/CodeTreeInterfaces.cpp b/Indexing/CodeTreeInterfaces.cpp index 52affd68e..4c3b26c0a 100644 --- a/Indexing/CodeTreeInterfaces.cpp +++ b/Indexing/CodeTreeInterfaces.cpp @@ -53,13 +53,11 @@ class CodeTreeSubstitution TermList applyToBoundResult(TermList t) override { - CALL("CodeTreeSubstitution::applyToBoundResult(TermList)"); return SubstHelper::apply(t, *getApplicator()); } Literal* applyToBoundResult(Literal* lit) override { - CALL("CodeTreeSubstitution::applyToBoundResult(Literal*)"); return SubstHelper::apply(lit, *getApplicator()); } @@ -134,8 +132,6 @@ class CodeTreeTIS::ResultIterator bool hasNext() { - CALL("CodeTreeTIS::ResultIterator::hasNext"); - if(_found) { return true; } @@ -152,7 +148,6 @@ class CodeTreeTIS::ResultIterator TermQueryResult next() { - CALL("CodeTreeTIS::ResultIterator::next"); ASS(_found); TermQueryResult res; @@ -181,23 +176,17 @@ class CodeTreeTIS::ResultIterator void CodeTreeTIS::insert(TypedTermList t, Literal* lit, Clause* cls) { - CALL("CodeTreeTIS::insert"); - TermCodeTree::TermInfo* ti=new TermCodeTree::TermInfo(t,lit,cls); _ct.insert(ti); } void CodeTreeTIS::remove(TypedTermList t, Literal* lit, Clause* cls) { - CALL("CodeTreeTIS::remove"); - _ct.remove(TermCodeTree::TermInfo(t,lit,cls)); } TermQueryResultIterator CodeTreeTIS::getGeneralizations(TypedTermList t, bool retrieveSubstitutions) { - CALL("CodeTreeTIS::getGeneralizations"); - if(_ct.isEmpty()) { return TermQueryResultIterator::getEmpty(); } @@ -207,8 +196,6 @@ TermQueryResultIterator CodeTreeTIS::getGeneralizations(TypedTermList t, bool re bool CodeTreeTIS::generalizationExists(TermList t) { - CALL("CodeTreeTIS::generalizationExists"); - if(_ct.isEmpty()) { return false; } @@ -236,7 +223,6 @@ class CodeTreeSubsumptionIndex::ClauseSResIterator bool hasNext() { - CALL("CodeTreeSubsumptionIndex::ClauseSResIterator::hasNext"); if(ready) { return result; } @@ -248,7 +234,6 @@ class CodeTreeSubsumptionIndex::ClauseSResIterator ClauseSResQueryResult next() { - CALL("CodeTreeSubsumptionIndex::ClauseSResIterator::next"); ASS(result); ready=false; @@ -268,8 +253,6 @@ class CodeTreeSubsumptionIndex::ClauseSResIterator void CodeTreeSubsumptionIndex::handleClause(Clause* cl, bool adding) { - CALL("CodeTreeSubsumptionIndex::handleClause"); - TIME_TRACE("codetree subsumption index maintanance"); if(adding) { @@ -283,8 +266,6 @@ void CodeTreeSubsumptionIndex::handleClause(Clause* cl, bool adding) ClauseSResResultIterator CodeTreeSubsumptionIndex ::getSubsumingOrSResolvingClauses(Clause* cl, bool subsumptionResolution) { - CALL("CodeTreeSubsumptionIndex::getSubsumingClauses"); - if(_ct.isEmpty()) { return ClauseSResResultIterator::getEmpty(); } diff --git a/Indexing/GroundingIndex.cpp b/Indexing/GroundingIndex.cpp index 14a789b0f..b9b5e09df 100644 --- a/Indexing/GroundingIndex.cpp +++ b/Indexing/GroundingIndex.cpp @@ -31,8 +31,6 @@ namespace Indexing GroundingIndex::GroundingIndex(const Options& opt) { - CALL("GroundingIndex::GroundingIndex"); - switch(opt.satSolver()){ #if VZ3 case Options::SatSolver::Z3: @@ -50,8 +48,6 @@ GroundingIndex::GroundingIndex(const Options& opt) void GroundingIndex::handleClause(Clause* c, bool adding) { - CALL("GroundingIndex::handleClause"); - //We are adding clauses into the index when performing the subsumption check } diff --git a/Indexing/IndexManager.cpp b/Indexing/IndexManager.cpp index 8e22bda24..9993d43e7 100644 --- a/Indexing/IndexManager.cpp +++ b/Indexing/IndexManager.cpp @@ -35,8 +35,6 @@ using namespace Indexing; Index* IndexManager::request(IndexType t) { - CALL("IndexManager::request"); - Entry e; if(_store.find(t,e)) { e.refCnt++; @@ -50,8 +48,6 @@ Index* IndexManager::request(IndexType t) void IndexManager::release(IndexType t) { - CALL("IndexManager::release"); - Entry e=_store.get(t); e.refCnt--; @@ -87,7 +83,6 @@ Index* IndexManager::get(IndexType t) */ void IndexManager::provideIndex(IndexType t, Index* index) { - CALL("IndexManager::provideIndex"); ASS(!_store.find(t)); Entry e; @@ -98,8 +93,6 @@ void IndexManager::provideIndex(IndexType t, Index* index) Index* IndexManager::create(IndexType t) { - CALL("IndexManager::create"); - Index* res; LiteralIndexingStructure* is; TermIndexingStructure* tis; diff --git a/Indexing/IndexManager.hpp b/Indexing/IndexManager.hpp index b79063b31..4481604eb 100644 --- a/Indexing/IndexManager.hpp +++ b/Indexing/IndexManager.hpp @@ -77,7 +77,6 @@ class IndexManager explicit IndexManager(SaturationAlgorithm* alg) : _alg(alg) {} void setSaturationAlgorithm(SaturationAlgorithm* alg) { - CALL("IndexManager::setSaturationAlgorithm"); ASS(!_alg); ASS(alg); _alg = alg; diff --git a/Indexing/InductionFormulaIndex.cpp b/Indexing/InductionFormulaIndex.cpp index 646f4cc06..b2a878490 100644 --- a/Indexing/InductionFormulaIndex.cpp +++ b/Indexing/InductionFormulaIndex.cpp @@ -53,7 +53,6 @@ Key InductionFormulaIndex::represent(const InductionContext& context) */ bool InductionFormulaIndex::findOrInsert(const InductionContext& context, Entry*& e, Literal* bound1, Literal* bound2) { - CALL("InductionFormulaIndex::insert"); ASS(!context._cls.empty()); auto k = represent(context); k.second.first = bound1; diff --git a/Indexing/LiteralIndex.cpp b/Indexing/LiteralIndex.cpp index 264841e98..bbe63a6d6 100644 --- a/Indexing/LiteralIndex.cpp +++ b/Indexing/LiteralIndex.cpp @@ -72,8 +72,6 @@ size_t LiteralIndex::getUnificationCount(Literal* lit, bool complementary) void LiteralIndex::handleLiteral(Literal* lit, Clause* cl, bool add) { - CALL("LiteralIndex::handleLiteral"); - if(add) { _is->insert(lit, cl); } else { @@ -83,8 +81,6 @@ void LiteralIndex::handleLiteral(Literal* lit, Clause* cl, bool add) void BinaryResolutionIndex::handleClause(Clause* c, bool adding) { - CALL("BinaryResolutionIndex::handleClause"); - TIME_TRACE("binary resolution index maintenance"); int selCnt=c->numSelected(); @@ -98,8 +94,6 @@ void BinaryResolutionIndex::handleClause(Clause* c, bool adding) void BackwardSubsumptionIndex::handleClause(Clause* c, bool adding) { - CALL("BackwardSubsumptionIndex::handleClause"); - TIME_TRACE("backward subsumption index maintenance"); unsigned clen=c->length(); @@ -111,8 +105,6 @@ void BackwardSubsumptionIndex::handleClause(Clause* c, bool adding) void FwSubsSimplifyingLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("FwSubsSimplifyingLiteralIndex::handleClause"); - if (c->length() < 2) { return; } @@ -125,8 +117,6 @@ void FwSubsSimplifyingLiteralIndex::handleClause(Clause* c, bool adding) void FSDLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("FSDLiteralIndex::handleClause"); - if (c->length() < 2) { return; } @@ -162,8 +152,6 @@ void FSDLiteralIndex::handleClause(Clause* c, bool adding) void UnitClauseLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("UnitClauseLiteralIndex::handleClause"); - if(c->length()==1) { TIME_TRACE("unit clause index maintenance"); @@ -173,8 +161,6 @@ void UnitClauseLiteralIndex::handleClause(Clause* c, bool adding) void NonUnitClauseLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("NonUnitClauseLiteralIndex::handleClause"); - unsigned clen=c->length(); if(clen<2) { return; @@ -208,7 +194,6 @@ RewriteRuleIndex::~RewriteRuleIndex() */ Literal* RewriteRuleIndex::getGreater(Clause* c) { - CALL("RewriteRuleIndex::getGreater"); ASS_EQ(c->length(), 2); static LiteralComparators::NormalizedLinearComparatorByWeight comparator; @@ -236,8 +221,6 @@ Literal* RewriteRuleIndex::getGreater(Clause* c) void RewriteRuleIndex::handleClause(Clause* c, bool adding) { - CALL("RewriteRuleIndex::handleClause"); - if(c->length()!=2) { return; } @@ -300,8 +283,6 @@ void RewriteRuleIndex::handleClause(Clause* c, bool adding) void RewriteRuleIndex::handleEquivalence(Clause* c, Literal* cgr, Clause* d, Literal* dgr, bool adding) { - CALL("RewriteRuleIndex::handleEquivalence"); - Literal* csm = (cgr==(*c)[0]) ? (*c)[1] : (*c)[0]; Literal* dsm = (dgr==(*d)[0]) ? (*d)[1] : (*d)[0]; @@ -392,8 +373,6 @@ void RewriteRuleIndex::handleEquivalence(Clause* c, Literal* cgr, Clause* d, Lit */ void DismatchingLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("DismatchingLiteralIndex::handleClause"); - //TODO add time counter for dismatching unsigned clen=c->length(); @@ -403,15 +382,12 @@ void DismatchingLiteralIndex::handleClause(Clause* c, bool adding) } void DismatchingLiteralIndex::addLiteral(Literal* l) { - CALL("DismatchingLiteralIndex::addLiteral"); //TODO is it safe to pass 0 here? handleLiteral(l,0,true); } void UnitIntegerComparisonLiteralIndex::handleClause(Clause* c, bool adding) { - CALL("UnitIntegerComparisonLiteralIndex::handleClause"); - TIME_TRACE("unit integer comparison literal index maintenance"); if (!Inferences::InductionHelper::isIntegerComparison(c)) { diff --git a/Indexing/LiteralIndexingStructure.hpp b/Indexing/LiteralIndexingStructure.hpp index 7124a6a9c..4cebc1324 100644 --- a/Indexing/LiteralIndexingStructure.hpp +++ b/Indexing/LiteralIndexingStructure.hpp @@ -42,7 +42,6 @@ class LiteralIndexingStructure { virtual size_t getUnificationCount(Literal* lit, bool complementary) { - CALL("LiteralIndexingStructure::getUnificationCount"); return countIteratorElements(getUnifications(lit, complementary, false)); } diff --git a/Indexing/LiteralMiniIndex.hpp b/Indexing/LiteralMiniIndex.hpp index 51f9e6421..ecdb69162 100644 --- a/Indexing/LiteralMiniIndex.hpp +++ b/Indexing/LiteralMiniIndex.hpp @@ -60,8 +60,6 @@ class LiteralMiniIndex : _ready(false), _hdr(complementary?query->complementaryHeader():query->header()), _query(query), _compl(complementary) { - CALL("LiteralMiniIndex::BaseIterator::BaseIterator"); - Entry const* arr=index._entries.array(); unsigned weight=query->weight(); if(arr[0]._header>=_hdr || index._cnt==1) { @@ -113,8 +111,6 @@ class LiteralMiniIndex bool hasNext() { - CALL("LiteralMiniIndex::InstanceIterator::hasNext"); - if(_ready) { return true; } while(_curr->_header==_hdr) { if(MatchingUtils::match(_query, _curr->_lit, _compl)) { @@ -140,8 +136,6 @@ class LiteralMiniIndex bool hasNext() { - CALL("LiteralMiniIndex::VariantIterator::hasNext"); - if(_ready) { return true; } while(_curr->_header==_hdr) { if(MatchingUtils::isVariant(_query, _curr->_lit)) { diff --git a/Indexing/LiteralSubstitutionTree.cpp b/Indexing/LiteralSubstitutionTree.cpp index c7081641f..88fade769 100644 --- a/Indexing/LiteralSubstitutionTree.cpp +++ b/Indexing/LiteralSubstitutionTree.cpp @@ -54,8 +54,6 @@ SLQueryResultIterator LiteralSubstitutionTree::getVariants(Literal* query, bool SLQueryResultIterator LiteralSubstitutionTree::getAll() { - CALL("LiteralSubstitutionTree::getAll"); - return pvi( iterTraits(getRangeIterator((unsigned long)0, _trees.size())) .flatMap([this](auto i) { return LeafIterator(&_trees[i]); }) @@ -76,8 +74,6 @@ SubstitutionTree& LiteralSubstitutionTree::getTree(Literal* lit, bool complement template SLQueryResultIterator LiteralSubstitutionTree::getResultIterator(Literal* lit, bool complementary, bool retrieveSubstitutions, bool useConstraints) { - CALL("LiteralSubstitutionTree::getResultIterator"); - auto iter = [&](bool reversed) { return iterTraits(getTree(lit, complementary).iterator(lit, retrieveSubstitutions, useConstraints, reversed)) ; }; diff --git a/Indexing/ResultSubstitution.cpp b/Indexing/ResultSubstitution.cpp index a7c1fe7d4..1c1b8f258 100644 --- a/Indexing/ResultSubstitution.cpp +++ b/Indexing/ResultSubstitution.cpp @@ -72,8 +72,6 @@ ResultSubstitutionSP ResultSubstitution::fromSubstitution(RobSubstitution* s, in */ bool ResultSubstitution::isRenamingOn(TermList t, bool result) { - CALL("ResultSubstitution::isRenamingOn"); - DHMap renamingInMaking; VariableIterator it(t); diff --git a/Indexing/ResultSubstitution.hpp b/Indexing/ResultSubstitution.hpp index aaccb6067..b0f2d95be 100644 --- a/Indexing/ResultSubstitution.hpp +++ b/Indexing/ResultSubstitution.hpp @@ -61,7 +61,6 @@ class ResultSubstitution template T apply(T t, bool result) { - CALL("ResultSubstitution::apply") if(result) { return applyToResult(t); } else { diff --git a/Indexing/SubstitutionTree.cpp b/Indexing/SubstitutionTree.cpp index 42c4f248e..3001da455 100644 --- a/Indexing/SubstitutionTree.cpp +++ b/Indexing/SubstitutionTree.cpp @@ -59,8 +59,6 @@ SubstitutionTree::SubstitutionTree(bool useC, bool rfSubs) , _tag(false) #endif { - CALL("SubstitutionTree::SubstitutionTree"); - } // SubstitutionTree::SubstitutionTree /** @@ -70,7 +68,6 @@ SubstitutionTree::SubstitutionTree(bool useC, bool rfSubs) */ SubstitutionTree::~SubstitutionTree() { - CALL("SubstitutionTree::~SubstitutionTree"); ASS_EQ(_iterCnt,0); delete _root; @@ -141,7 +138,6 @@ struct BindingComparator void SubstitutionTree::insert(BindingMap& svBindings, LeafData ld) { #define DEBUG_INSERT(...) // DBG(__VA_ARGS__) - CALL("SubstitutionTree::insert"); ASS_EQ(_iterCnt,0); auto pnode = &_root; DEBUG_INSERT("insert: ", svBindings, " into ", *this) @@ -356,7 +352,6 @@ void SubstitutionTree::insert(BindingMap& svBindings, LeafData ld) */ void SubstitutionTree::remove(BindingMap& svBindings, LeafData ld) { - CALL("SubstitutionTree::remove"); ASS_EQ(_iterCnt,0); auto pnode = &_root; @@ -452,7 +447,6 @@ void SubstitutionTree::remove(BindingMap& svBindings, LeafData ld) */ SubstitutionTree::Leaf* SubstitutionTree::findLeaf(Node* root, BindingMap& svBindings) { - CALL("SubstitutionTree::findLeaf"); ASS(root); Node* node=root; @@ -534,8 +528,6 @@ vstring getIndentStr(int n) SubstitutionTree::Node::~Node() { - CALL("SubstitutionTree::Node::~Node"); - if(term.isTerm()) { term.term()->destroyNonShared(); } @@ -544,8 +536,6 @@ SubstitutionTree::Node::~Node() void SubstitutionTree::Node::split(Node** pnode, TermList* where, int var) { - CALL("SubstitutionTree::Node::split"); - Node* node=*pnode; IntermediateNode* newNode = createIntermediateNode(node->term, var,node->withSorts()); @@ -561,8 +551,6 @@ void SubstitutionTree::Node::split(Node** pnode, TermList* where, int var) void SubstitutionTree::IntermediateNode::loadChildren(NodeIterator children) { - CALL("SubstitutionTree::IntermediateNode::loadChildren"); - while(children.hasNext()) { Node* ext=*children.next(); Node** own=childByTop(ext->term, true); @@ -573,8 +561,6 @@ void SubstitutionTree::IntermediateNode::loadChildren(NodeIterator children) void SubstitutionTree::Leaf::loadChildren(LDIterator children) { - CALL("SubstitutionTree::Leaf::loadClauses"); - while(children.hasNext()) { LeafData ld=children.next(); insert(ld); @@ -626,7 +612,6 @@ void SubstitutionTree::LeafIterator::skipToNextLeaf() bool SubstitutionTree::LeafIterator::hasNext() { - CALL("SubstitutionTree::Leaf::hasNext"); return _curr != nullptr; } @@ -645,8 +630,6 @@ SubstitutionTree::UnificationsIterator::~UnificationsIterator() bool SubstitutionTree::UnificationsIterator::hasNext() { - CALL("SubstitutionTree::UnificationsIterator::hasNext"); - if(_clientBDRecording) { _subst->bdDone(); _clientBDRecording=false; @@ -659,8 +642,6 @@ bool SubstitutionTree::UnificationsIterator::hasNext() SubstitutionTree::QueryResult SubstitutionTree::UnificationsIterator::next() { - CALL("SubstitutionTree::UnificationsIterator::next"); - while(!_ldIterator.hasNext() && findNextLeaf()) {} ASS(_ldIterator.hasNext()); @@ -696,8 +677,6 @@ SubstitutionTree::QueryResult SubstitutionTree::UnificationsIterator::next() bool SubstitutionTree::UnificationsIterator::findNextLeaf() { - CALL("SubstitutionTree::UnificationsIterator::findNextLeaf"); - if(_nodeIterators->isEmpty()) { //There are no node iterators in the stack, so there's nowhere //to look for the next leaf. @@ -744,8 +723,6 @@ bool SubstitutionTree::UnificationsIterator::findNextLeaf() bool SubstitutionTree::UnificationsIterator::enter(Node* n, BacktrackData& bd) { - CALL("SubstitutionTree::UnificationsIterator::enter"); - #if VDEBUG if(_tag){ cout << "=========================================" << endl; @@ -793,8 +770,6 @@ bool SubstitutionTree::UnificationsIterator::enter(Node* n, BacktrackData& bd) bool SubstitutionTree::SubstitutionTreeMismatchHandler::introduceConstraint(TermList query,unsigned index1, TermList node,unsigned index2) { - CALL("SubstitutionTree::MismatchHandler::introduceConstraint"); - auto constraint = make_pair(make_pair(query,index1),make_pair(node,index2)); _constraints.backtrackablePush(constraint,_bd); return true; @@ -803,8 +778,6 @@ bool SubstitutionTree::SubstitutionTreeMismatchHandler::introduceConstraint(Term bool SubstitutionTree::STHOMismatchHandler::handle (RobSubstitution* subst,TermList query,unsigned index1, TermList node,unsigned index2) { - CALL("SubstitutionTree::STHOMismatchHandler::handle"); - auto constraint = make_pair(make_pair(query,index1),make_pair(node,index2)); _constraints.backtrackablePush(constraint,_bd); return true; @@ -816,8 +789,6 @@ bool SubstitutionTree::STHOMismatchHandler::handle */ bool SubstitutionTree::UnificationsIterator::associate(TermList query, TermList node, BacktrackData& bd) { - CALL("SubstitutionTree::UnificationsIterator::associate"); - //The ordering of the if statements is important here. Higher-order problems //should never require theory resoning (at the moment, theories cannot be parsed in HOL) //However, a user can still set UWA option on. We don't wan't that to result in @@ -837,8 +808,6 @@ bool SubstitutionTree::UnificationsIterator::associate(TermList query, TermList //for them SubstitutionTree::NodeIterator SubstitutionTree::UnificationsIterator::getNodeIterator(IntermediateNode* n) { - CALL("SubstitutionTree::UnificationsIterator::getNodeIterator"); - unsigned specVar=n->childVar; TermList qt=_subst->getSpecialVarTop(specVar); if(qt.isVar()) { diff --git a/Indexing/SubstitutionTree.hpp b/Indexing/SubstitutionTree.hpp index 24777f970..fd52c4c78 100644 --- a/Indexing/SubstitutionTree.hpp +++ b/Indexing/SubstitutionTree.hpp @@ -189,7 +189,6 @@ class SubstitutionTree template QueryResultIterator iterator(TermOrLit query, bool retrieveSubstitutions, bool withConstraints, bool reversed = false) { - CALL("TermSubstitutionTree::iterator"); return _root == nullptr ? QueryResultIterator::getEmpty() : pvi(iterTraits(Iterator(this, _root, query, retrieveSubstitutions, reversed, withConstraints, _functionalSubtermMap.asPtr() ))); @@ -201,8 +200,6 @@ class SubstitutionTree inline static Comparison compare(const LeafData& ld1, const LeafData& ld2) { - CALL("SubstitutionTree::LDComparator::compare"); - if(ld1.clause && ld2.clause && ld1.clause!=ld2.clause) { ASS_NEQ(ld1.clause->number(), ld2.clause->number()); return (ld1.clause->number()number()) ? LESS : GREATER; @@ -328,7 +325,6 @@ class SubstitutionTree */ NodeIterator childBySort(TermList t) { - CALL("SubstitutionTree::ChildBySortHelper::childBySort"); TermList srt; // only consider interpreted sorts if(SortHelper::tryGetResultSort(t,srt) && !srt.isVar()){ @@ -354,7 +350,6 @@ class SubstitutionTree */ void mightExistAsTop(TermList t) { - CALL("SubstitutionTree::ChildBySortHelper::mightExistAsTop"); if(!t.isTerm()){ return; } TermList srt; if(SortHelper::tryGetResultSort(t,srt) && !srt.isVar() && @@ -370,7 +365,6 @@ class SubstitutionTree } void remove(TermList t) { - CALL("SubstitutionTree::ChildBySortHelper::remove"); if(!t.isTerm()){ return;} TermList srt; if(SortHelper::tryGetResultSort(t,srt) && !srt.isVar() && @@ -638,8 +632,6 @@ class SubstitutionTree } virtual Node** childByTop(TermList t, bool canCreate) { - CALL("SubstitutionTree::SListIntermediateNode::childByTop"); - Node** res; bool found=_nodes.getPosition(t,res,canCreate); if(!found) { @@ -669,8 +661,6 @@ class SubstitutionTree public: static Comparison compare(TermList t1,TermList t2) { - CALL("SubstitutionTree::SListIntermediateNode::NodePtrComparator::compare"); - if(t1.isVar()) { if(t2.isVar()) { return Int::compare(t1.var(), t2.var()); @@ -851,9 +841,6 @@ class SubstitutionTree template QueryResultIterator getVariants(Query query, bool retrieveSubstitutions) { - CALL("LiteralSubstitutionTree::getVariants"); - - RenamingSubstitution* renaming = retrieveSubstitutions ? new RenamingSubstitution() : nullptr; ResultSubstitutionSP resultSubst = retrieveSubstitutions ? ResultSubstitutionSP(renaming) : ResultSubstitutionSP(); @@ -1071,7 +1058,6 @@ class SubstitutionTree , _nodeTypes() , _iterCntr(parent->_iterCnt) { - CALL("SubstitutionTree::FastGeneralizationsIterator::FastGeneralizationsIterator"); ASS(root); ASS(!root->isLeaf()); @@ -1139,8 +1125,6 @@ class SubstitutionTree TermSpec(bool q, TermList t) : q(q), t(t) { - CALL("SubstitutionTree::InstMatcher::TermSpec::TermSpec"); - //query does not contain special vars ASS(!q || !t.isTerm() || t.term()->shared()); ASS(!q || !t.isSpecialVar()); @@ -1148,7 +1132,6 @@ class SubstitutionTree vstring toString() { - CALL("SubstitutionTree::InstMatcher::TermSpec::toString"); return (q ? "q|" : "n|")+t.toString(); } @@ -1176,7 +1159,6 @@ class SubstitutionTree */ void bindSpecialVar(unsigned var, TermList term) { - CALL("SubstitutionTree::InstMatcher::bindSpecialVar"); ASS_EQ(getBSCnt(), 0); ALWAYS(_bindings.insert(TermList(var,true),TermSpec(true,term))); @@ -1232,14 +1214,12 @@ class SubstitutionTree bool isBound(TermList var) { - CALL("SubstitutionTree::InstMatcher::isBound"); ASS(var.isVar()); return _bindings.find(var); } void bind(TermList var, TermSpec trm) { - CALL("SubstitutionTree::InstMatcher::bind"); ASS(!var.isOrdinaryVar() || !trm.q); //we do not bind ordinary vars to query terms ALWAYS(_bindings.insert(var, trm)); @@ -1278,7 +1258,6 @@ class SubstitutionTree DerefApplicator(InstMatcher* im, bool query) : query(query), im(im) {} TermList apply(unsigned var) { - CALL("SubstitutionTree::InstMatcher::DerefApplicator::apply"); if(query) { return im->_derefBindings.get(TermList(var, false)); } @@ -1288,7 +1267,6 @@ class SubstitutionTree } TermList applyToSpecVar(unsigned specVar) { - CALL("SubstitutionTree::InstMatcher::DerefApplicator::applyToSpecVar"); ASS(!query); return im->_derefBindings.get(TermList(specVar, true)); @@ -1327,7 +1305,6 @@ class SubstitutionTree , _nodeTypes() , _iterCntr(parent->_iterCnt) { - CALL("SubstitutionTree::FastInstancesIterator::FastInstancesIterator"); ASS(root); ASS(!root->isLeaf()); @@ -1410,8 +1387,6 @@ class SubstitutionTree #endif { #define DEBUG_QUERY(...) // DBG(__VA_ARGS__) - CALL("SubstitutionTree::UnificationsIterator::UnificationsIterator"); - ASS(!_useUWAConstraints || retrieveSubstitution); ASS(!_useUWAConstraints || parent->_useC); diff --git a/Indexing/SubstitutionTree_FastGen.cpp b/Indexing/SubstitutionTree_FastGen.cpp index dee8a5ff2..fe1ff63bc 100644 --- a/Indexing/SubstitutionTree_FastGen.cpp +++ b/Indexing/SubstitutionTree_FastGen.cpp @@ -148,8 +148,6 @@ class SubstitutionTree::GenMatcher::Substitution bool SubstitutionTree::GenMatcher::matchNext(unsigned specVar, TermList nodeTerm, bool separate) { - CALL("SubstitutionTree::GenMatcher::matchNext"); - if(separate) { _boundVars->push(BACKTRACK_SEPARATOR); } @@ -170,8 +168,6 @@ bool SubstitutionTree::GenMatcher::matchNext(unsigned specVar, TermList nodeTerm */ bool SubstitutionTree::GenMatcher::matchNextAux(TermList queryTerm, TermList nodeTerm, bool separate) { - CALL("SubstitutionTree::GenMatcher::matchNextAux"); - bool success; if(nodeTerm.isTerm()) { Term* nt=nodeTerm.term(); @@ -217,8 +213,6 @@ bool SubstitutionTree::GenMatcher::matchNextAux(TermList queryTerm, TermList nod */ void SubstitutionTree::GenMatcher::backtrack() { - CALL("SubstitutionTree::GenMatcher::backtrack"); - for(;;) { unsigned boundVar = _boundVars->pop(); if(boundVar==BACKTRACK_SEPARATOR) { @@ -237,8 +231,6 @@ void SubstitutionTree::GenMatcher::backtrack() */ bool SubstitutionTree::GenMatcher::tryBacktrack() { - CALL("SubstitutionTree::GenMatcher::tryBacktrack"); - while(_boundVars->isNonEmpty()) { unsigned boundVar = _boundVars->pop(); if(boundVar==BACKTRACK_SEPARATOR) { @@ -261,16 +253,12 @@ ResultSubstitutionSP SubstitutionTree::GenMatcher::getSubstitution( bool SubstitutionTree::FastGeneralizationsIterator::hasNext() { - CALL("SubstitutionTree::FastGeneralizationsIterator::hasNext"); - while(!_ldIterator.hasNext() && findNextLeaf()) {} return _ldIterator.hasNext(); } SubstitutionTree::QueryResult SubstitutionTree::FastGeneralizationsIterator::next() { - CALL("SubstitutionTree::FastGeneralizationsIterator::next"); - while(!_ldIterator.hasNext() && findNextLeaf()) {} ASS(_ldIterator.hasNext()); LeafData& ld=_ldIterator.next(); @@ -295,8 +283,6 @@ SubstitutionTree::QueryResult SubstitutionTree::FastGeneralizationsIterator::nex */ bool SubstitutionTree::FastGeneralizationsIterator::findNextLeaf() { - CALL("SubstitutionTree::FastGeneralizationsIterator::findNextLeaf"); - Node* curr; bool sibilingsRemain = false; if(_inLeaf) { diff --git a/Indexing/SubstitutionTree_FastInst.cpp b/Indexing/SubstitutionTree_FastInst.cpp index cdac2b9bb..f244e0f2e 100644 --- a/Indexing/SubstitutionTree_FastInst.cpp +++ b/Indexing/SubstitutionTree_FastInst.cpp @@ -27,8 +27,6 @@ namespace Indexing std::ostream& operator<< (ostream& out, SubstitutionTree::InstMatcher::TermSpec ts ) { - CALL("operator<<(ostream&,SubstitutionTree::InstMatcher::TermSpec)"); - out<derefQueryBinding(var); ASS_REP(!normalized.isTerm() || normalized.term()->shared(), normalized); return _resultDenormalizer->apply(normalized); @@ -79,16 +73,12 @@ class SubstitutionTree::InstMatcher::Substitution ResultSubstitutionSP SubstitutionTree::InstMatcher::getSubstitution(Renaming* resultDenormalizer) { - CALL("SubstitutionTree::InstMatcher::getSubstitution"); - return ResultSubstitutionSP( new Substitution(this, resultDenormalizer)); } TermList SubstitutionTree::InstMatcher::derefQueryBinding(unsigned var) { - CALL("SubstitutionTree::InstMatcher::derefQueryBinding"); - TermList tvar0(var, false); TermList tvar=tvar0; @@ -162,7 +152,6 @@ TermList SubstitutionTree::InstMatcher::derefQueryBinding(unsigned var) SubstitutionTree::InstMatcher::TermSpec SubstitutionTree::InstMatcher::deref(TermList var) { - CALL("SubstitutionTree::InstMatcher::deref"); ASS_REP(var.isVar(), var.tag()); #if VDEBUG @@ -191,8 +180,6 @@ SubstitutionTree::InstMatcher::TermSpec SubstitutionTree::InstMatcher::deref(Ter */ void SubstitutionTree::InstMatcher::backtrack() { - CALL("SubstitutionTree::InstMatcher::backtrack"); - for(;;) { TermList boundVar=_boundVars.pop(); if(boundVar.isEmpty()) { @@ -211,8 +198,6 @@ void SubstitutionTree::InstMatcher::backtrack() */ bool SubstitutionTree::InstMatcher::tryBacktrack() { - CALL("SubstitutionTree::InstMatcher::tryBacktrack"); - while(_boundVars.isNonEmpty()) { TermList boundVar=_boundVars.pop(); if(boundVar.isEmpty()) { @@ -226,8 +211,6 @@ bool SubstitutionTree::InstMatcher::tryBacktrack() bool SubstitutionTree::InstMatcher::matchNext(unsigned specVar, TermList nodeTerm, bool separate) { - CALL("SubstitutionTree::InstMatcher::matchNext"); - if(separate) { TermList sep; sep.makeEmpty(); @@ -257,8 +240,6 @@ bool SubstitutionTree::InstMatcher::matchNext(unsigned specVar, TermList nodeTer */ bool SubstitutionTree::InstMatcher::matchNextAux(TermList queryTerm, TermList nodeTerm, bool separate) { - CALL("SubstitutionTree::InstMatcher::matchNextAux"); - unsigned specVar; TermSpec tsBinding; @@ -368,8 +349,6 @@ bool SubstitutionTree::InstMatcher::matchNextAux(TermList queryTerm, TermList no bool SubstitutionTree::FastInstancesIterator::hasNext() { - CALL("SubstitutionTree::FastInstancesIterator::hasNext"); - while(!_ldIterator.hasNext() && findNextLeaf()) {} return _ldIterator.hasNext(); } @@ -379,8 +358,6 @@ bool SubstitutionTree::FastInstancesIterator::hasNext() SubstitutionTree::QueryResult SubstitutionTree::FastInstancesIterator::next() { - CALL("SubstitutionTree::FastInstancesIterator::next"); - while(!_ldIterator.hasNext() && findNextLeaf()) {} ASS(_ldIterator.hasNext()); LeafData& ld=_ldIterator.next(); @@ -414,8 +391,6 @@ SubstitutionTree::QueryResult SubstitutionTree::FastInstancesIterator::next() */ bool SubstitutionTree::FastInstancesIterator::findNextLeaf() { - CALL("SubstitutionTree::FastInstancesIterator::findNextLeaf"); - Node* curr; bool sibilingsRemain = false; if(_inLeaf) { @@ -559,7 +534,6 @@ bool SubstitutionTree::FastInstancesIterator::findNextLeaf() */ bool SubstitutionTree::FastInstancesIterator::enterNode(Node*& curr) { - CALL("SubstitutionTree::FastInstancesIterator::enterNode"); ASSERT_VALID(*curr); ASS(!curr->isLeaf()); diff --git a/Indexing/SubstitutionTree_Nodes.cpp b/Indexing/SubstitutionTree_Nodes.cpp index 1826b802e..30fd7488e 100644 --- a/Indexing/SubstitutionTree_Nodes.cpp +++ b/Indexing/SubstitutionTree_Nodes.cpp @@ -56,14 +56,12 @@ class SubstitutionTree::UListLeaf inline void insert(LeafData ld) { - CALL("SubstitutionTree::UListLeaf::insert"); LDList::push(ld, _children); _size++; } inline void remove(LeafData ld) { - CALL("SubstitutionTree::UListLeaf::remove"); _children = LDList::remove(ld, _children); _size--; } @@ -100,11 +98,9 @@ class SubstitutionTree::SListLeaf return pvi( LDSkipList::RefIterator(_children) ); } void insert(LeafData ld) { - CALL("SubstitutionTree::SListLeaf::insert"); _children.insert(ld); } void remove(LeafData ld) { - CALL("SubstitutionTree::SListLeaf::remove"); _children.remove(ld); } @@ -130,14 +126,12 @@ SubstitutionTree::Leaf* SubstitutionTree::createLeaf(TermList ts) SubstitutionTree::IntermediateNode* SubstitutionTree::createIntermediateNode(unsigned childVar,bool useC) { - CALL("SubstitutionTree::createIntermediateNode/2"); if(useC){ return new UArrIntermediateNodeWithSorts(childVar); } return new UArrIntermediateNode(childVar); } SubstitutionTree::IntermediateNode* SubstitutionTree::createIntermediateNode(TermList ts, unsigned childVar,bool useC) { - CALL("SubstitutionTree::createIntermediateNode/3"); if(useC){ return new UArrIntermediateNodeWithSorts(ts, childVar); } return new UArrIntermediateNode(ts, childVar); } @@ -165,8 +159,6 @@ void SubstitutionTree::IntermediateNode::destroyChildren() SubstitutionTree::Node** SubstitutionTree::UArrIntermediateNode::childByTop(TermList t, bool canCreate) { - CALL("SubstitutionTree::UArrIntermediateNode::childByTop"); - for(int i=0;i<_size;i++) { if(TermList::sameTop(t, _nodes[i]->term)) { return &_nodes[i]; @@ -184,8 +176,6 @@ SubstitutionTree::Node** SubstitutionTree::UArrIntermediateNode::childByTop(Term void SubstitutionTree::UArrIntermediateNode::remove(TermList t) { - CALL("SubstitutionTree::UArrIntermediateNode::remove"); - for(int i=0;i<_size;i++) { if(TermList::sameTop(t, _nodes[i]->term)) { _size--; @@ -204,8 +194,6 @@ void SubstitutionTree::UArrIntermediateNode::remove(TermList t) SubstitutionTree::IntermediateNode* SubstitutionTree::SListIntermediateNode ::assimilate(IntermediateNode* orig) { - CALL("SubstitutionTree::SListIntermediateNode::assimilate"); - IntermediateNode* res= 0; if(orig->withSorts()){ res = new SListIntermediateNodeWithSorts(orig->term, orig->childVar); @@ -225,8 +213,6 @@ SubstitutionTree::IntermediateNode* SubstitutionTree::SListIntermediateNode */ SubstitutionTree::SListLeaf* SubstitutionTree::SListLeaf::assimilate(Leaf* orig) { - CALL("SubstitutionTree::SListLeaf::assimilate"); - SListLeaf* res=new SListLeaf(orig->term); res->loadChildren(orig->allChildren()); orig->makeEmpty(); @@ -236,8 +222,6 @@ SubstitutionTree::SListLeaf* SubstitutionTree::SListLeaf::assimilate(Leaf* orig) void SubstitutionTree::ensureLeafEfficiency(Leaf** leaf) { - CALL("SubstitutionTree::ensureLeafEfficiency"); - if( (*leaf)->algorithm()==UNSORTED_LIST && (*leaf)->size()>5 ) { *leaf=SListLeaf::assimilate(*leaf); } @@ -245,8 +229,6 @@ void SubstitutionTree::ensureLeafEfficiency(Leaf** leaf) void SubstitutionTree::ensureIntermediateNodeEfficiency(IntermediateNode** inode) { - CALL("SubstitutionTree::ensureIntermediateNodeEfficiency"); - if( (*inode)->algorithm()==UNSORTED_LIST && (*inode)->size()>3 ) { *inode=SListIntermediateNode::assimilate(*inode); } diff --git a/Indexing/TermCodeTree.cpp b/Indexing/TermCodeTree.cpp index d7d38d315..15aa827c6 100644 --- a/Indexing/TermCodeTree.cpp +++ b/Indexing/TermCodeTree.cpp @@ -34,8 +34,6 @@ using namespace Kernel; void TermCodeTree::onCodeOpDestroying(CodeOp* op) { - CALL("TermCodeTree::onCodeOpDestroying"); - if (op->isSuccess()) { delete static_cast(op->getSuccessResult()); } @@ -49,8 +47,6 @@ TermCodeTree::TermCodeTree() void TermCodeTree::insert(TermInfo* ti) { - CALL("TermCodeTree::insert"); - static CodeStack code; code.reset(); @@ -78,8 +74,6 @@ void TermCodeTree::insert(TermInfo* ti) void TermCodeTree::remove(const TermInfo& ti) { - CALL("TermCodeTree::remove"); - static RemovingTermMatcher rtm; static Stack firstsInBlocks; firstsInBlocks.reset(); @@ -131,8 +125,6 @@ void TermCodeTree::remove(const TermInfo& ti) void TermCodeTree::RemovingTermMatcher::init(FlatTerm* ft_, TermCodeTree* tree_, Stack* firstsInBlocks_) { - CALL("TermCodeTree::RemovingTermMatcher::init"); - RemovingMatcher::init(tree_->getEntryPoint(), 0, 0, tree_, firstsInBlocks_); firstsInBlocks->push(entry); @@ -153,8 +145,6 @@ TermCodeTree::TermMatcher::TermMatcher() void TermCodeTree::TermMatcher::init(CodeTree* tree, TermList t) { - CALL("TermCodeTree::TermMatcher::init"); - Matcher::init(tree,tree->getEntryPoint()); linfos=0; @@ -169,8 +159,6 @@ void TermCodeTree::TermMatcher::init(CodeTree* tree, TermList t) void TermCodeTree::TermMatcher::reset() { - CALL("TermCodeTree::TermMatcher::reset"); - ft->destroy(); #if VDEBUG ft=0; @@ -179,8 +167,6 @@ void TermCodeTree::TermMatcher::reset() TermCodeTree::TermInfo* TermCodeTree::TermMatcher::next() { - CALL("TermCodeTree::TermMatcher::next"); - if (finished()) { //all possible matches are exhausted return 0; diff --git a/Indexing/TermIndex.cpp b/Indexing/TermIndex.cpp index 12b350e7b..b27cdc7b7 100644 --- a/Indexing/TermIndex.cpp +++ b/Indexing/TermIndex.cpp @@ -53,8 +53,6 @@ TermQueryResultIterator TermIndex::getInstances(TypedTermList t, bool retrieveSu void SuperpositionSubtermIndex::handleClause(Clause* c, bool adding) { - CALL("SuperpositionSubtermIndex::handleClause"); - TIME_TRACE("backward superposition index maintenance"); unsigned selCnt=c->numSelected(); @@ -72,8 +70,6 @@ void SuperpositionSubtermIndex::handleClause(Clause* c, bool adding) void SuperpositionLHSIndex::handleClause(Clause* c, bool adding) { - CALL("SuperpositionLHSIndex::handleClause"); - TIME_TRACE("forward superposition index maintenance"); unsigned selCnt=c->numSelected(); @@ -89,8 +85,6 @@ void SuperpositionLHSIndex::handleClause(Clause* c, bool adding) template void DemodulationSubtermIndexImpl::handleClause(Clause* c, bool adding) { - CALL("DemodulationSubtermIndex::handleClause"); - TIME_TRACE("backward demodulation index maintenance"); static DHSet inserted; @@ -132,8 +126,6 @@ template class DemodulationSubtermIndexImpl; void DemodulationLHSIndex::handleClause(Clause* c, bool adding) { - CALL("DemodulationLHSIndex::handleClause"); - if (c->length()!=1) { return; } @@ -149,8 +141,6 @@ void DemodulationLHSIndex::handleClause(Clause* c, bool adding) void InductionTermIndex::handleClause(Clause* c, bool adding) { - CALL("InductionTermIndex::handleClause"); - TIME_TRACE("induction term index maintenance"); if (InductionHelper::isInductionClause(c)) { @@ -181,8 +171,6 @@ void InductionTermIndex::handleClause(Clause* c, bool adding) void StructInductionTermIndex::handleClause(Clause* c, bool adding) { - CALL("StructInductionTermIndex::handleClause"); - if (!InductionHelper::isInductionClause(c)) { return; } @@ -222,9 +210,6 @@ void StructInductionTermIndex::handleClause(Clause* c, bool adding) void SubVarSupSubtermIndex::handleClause(Clause* c, bool adding) { - CALL("SubVarSupSubtermIndex::handleClause"); - - DHSet unstableVars; c->collectUnstableVars(unstableVars); @@ -240,8 +225,6 @@ void SubVarSupSubtermIndex::handleClause(Clause* c, bool adding) void SubVarSupLHSIndex::handleClause(Clause* c, bool adding) { - CALL("SubVarSupLHSIndex::handleClause"); - unsigned selCnt=c->numSelected(); for (unsigned i=0; ipiSet(); @@ -333,8 +314,6 @@ void PrimitiveInstantiationIndex::populateIndex() void NarrowingIndex::populateIndex() { - CALL("NarrowingIndex::populateIndex"); - typedef ApplicativeHelper AH; static Options::Narrow set = env.options->narrow(); @@ -397,7 +376,6 @@ void NarrowingIndex::populateIndex() void SkolemisingFormulaIndex::insertFormula(TermList formula, TermList skolem) { - CALL("SkolemisingFormulaIndex::insertFormula"); _is->insert(TypedTermList(formula.term()), skolem); } diff --git a/Indexing/TermSharing.cpp b/Indexing/TermSharing.cpp index 08d0f4301..872a824a0 100644 --- a/Indexing/TermSharing.cpp +++ b/Indexing/TermSharing.cpp @@ -42,7 +42,6 @@ TermSharing::TermSharing() : _poly(true), _wellSortednessCheckingDisabled(false) { - CALL("TermSharing::TermSharing"); } /** @@ -51,8 +50,6 @@ TermSharing::TermSharing() */ TermSharing::~TermSharing() { - CALL("TermSharing::~TermSharing"); - #if CHECK_LEAKS Set::Iterator ts(_terms); while (ts.hasNext()) { @@ -71,8 +68,6 @@ TermSharing::~TermSharing() void TermSharing::setPoly() { - CALL("TermSharing::setPoly()"); - //combinatory superposiiton can introduce polymorphism into a monomorphic problem _poly = env.getMainProblem()->isHigherOrder() || env.getMainProblem()->hasPolymorphicSym() || (env.options->equalityProxy() != Options::EqualityProxy::OFF && !env.options->useMonoEqualityProxy()); @@ -85,7 +80,6 @@ void TermSharing::setPoly() Term* TermSharing::insert(Term* t) { - CALL("TermSharing::insert(Term*)"); ASS(!t->isLiteral()); ASS(!t->isSpecial()); ASS(!t->isSort()); @@ -211,7 +205,6 @@ Term* TermSharing::insert(Term* t) AtomicSort* TermSharing::insert(AtomicSort* sort) { - CALL("TermSharing::insert(AtomicSort*)"); ASS(!sort->isLiteral()); ASS(!sort->isSpecial()); ASS(sort->isSort()); @@ -268,7 +261,6 @@ AtomicSort* TermSharing::insert(AtomicSort* sort) */ Literal* TermSharing::insert(Literal* t) { - CALL("TermSharing::insert(Literal*)"); ASS(t->isLiteral()); ASS(!t->isSort()); ASS(!t->isSpecial()); @@ -350,7 +342,6 @@ Literal* TermSharing::insert(Literal* t) */ Literal* TermSharing::insertVariableEquality(Literal* t, TermList sort) { - CALL("TermSharing::insertVariableEquality"); ASS(t->isLiteral()); ASS(t->commutative()); ASS(t->isEquality()); @@ -402,8 +393,6 @@ Literal* TermSharing::insertVariableEquality(Literal* t, TermList sort) */ Literal* TermSharing::tryGetOpposite(Literal* l) { - CALL("TermSharing::tryGetOpposite"); - Literal* res; if(_literals.find(OpLitWrapper(l), res)) { return res; @@ -414,8 +403,6 @@ Literal* TermSharing::tryGetOpposite(Literal* l) int TermSharing::sumRedLengths(TermStack& args) { - CALL("TermSharing::sumRedLengths"); - int redLength = 0; for(unsigned i = 0; i < args.size(); i++){ @@ -437,8 +424,6 @@ int TermSharing::sumRedLengths(TermStack& args) */ bool TermSharing::argNormGt(TermList t1, TermList t2) { - CALL("TermSharing::argNormGt"); - if(t1.tag()!=t2.tag()) { return t1.tag()>t2.tag(); } @@ -464,8 +449,6 @@ bool TermSharing::argNormGt(TermList t1, TermList t2) */ bool TermSharing::equals(const Term* s,const Term* t) { - CALL("TermSharing::equals(Term*,Term*)"); - if (s->functor() != t->functor()) return false; const TermList* ss = s->args(); @@ -486,8 +469,6 @@ bool TermSharing::equals(const Term* s,const Term* t) template bool TermSharing::equals(const Literal* l1, const Literal* l2) { - CALL("TermSharing::equals(Literal*,Literal*)"); - if( (l1->polarity()==l2->polarity()) == opposite) { return false; } diff --git a/Inferences/ArgCong.cpp b/Inferences/ArgCong.cpp index 7fa5cf5ec..65c1a7e88 100644 --- a/Inferences/ArgCong.cpp +++ b/Inferences/ArgCong.cpp @@ -62,8 +62,6 @@ struct ArgCong::ResultFn } Clause* operator() (Literal* lit) { - CALL("ArgCong::ResultFn::operator()"); - ASS(lit->isEquality()); ASS(lit->isPositive()); @@ -139,8 +137,6 @@ struct ArgCong::ResultFn ClauseIterator ArgCong::generateClauses(Clause* premise) { - CALL("ArgCong::generateClauses"); - //cout << "argcong with " + premise->toString() << endl; if(premise->isEmpty()) { return ClauseIterator::getEmpty(); diff --git a/Inferences/ArithmeticSubtermGeneralization.cpp b/Inferences/ArithmeticSubtermGeneralization.cpp index ec80473cc..7c58a3576 100644 --- a/Inferences/ArithmeticSubtermGeneralization.cpp +++ b/Inferences/ArithmeticSubtermGeneralization.cpp @@ -79,7 +79,6 @@ static const auto iterVars = [](Clause* cl) { template SimplifyingGeneratingInference1::Result generalizeBottomUp(Clause* cl, EvalFn eval) { - CALL("generalizeBottomUp") /* apply the selectedGen generalization */ bool anyChange = false; bool oneLess = false; @@ -87,11 +86,9 @@ SimplifyingGeneratingInference1::Result generalizeBottomUp(Clause* cl, EvalFn ev auto stack = iterTraits(cl->iterLits()) .map([&](Literal* lit) -> Literal* { - CALL("generalizeBottomUp(Clause* cl, EvalFn)@closure 1") unsigned j = 0; auto termArgs = termArgIter(lit) .map([&](TermList term) -> TermList { - CALL("generalizeBottomUp(Clause* cl, EvalFn)@closure 2") auto norm = PolyNf::normalize(TypedTermList(term, SortHelper::getTermArgSort(lit, j++))); auto res = evaluateBottomUp(norm, eval); if (res != norm) { @@ -175,7 +172,6 @@ struct EvaluateAnyPoly PolyNf operator()(PolyNf term, PolyNf* evaluatedArgs) { - CALL("EvaluateAnyPoly::operator()") auto out = term.match( [&](Perfect t) -> PolyNf { return perfect(FuncTerm(t->function(), evaluatedArgs)); }, @@ -213,13 +209,11 @@ struct EvaluatePolynom AnyPoly operator()(AnyPoly poly, PolyNf* evaluatedArgs) { - CALL("EvaluatePolynom::operator()(AnyPoly, PolyNf*)") return poly.apply(EvalPolynomClsr{eval, evaluatedArgs}); } PolyNf operator()(PolyNf term, PolyNf* evaluatedArgs) { - CALL("EvaluatePolynom::operator()") return EvaluateAnyPoly{*this}(term, evaluatedArgs); } }; @@ -235,8 +229,6 @@ struct EvaluateMonom template Perfect> operator()(Perfect> poly, PolyNf* evaluatedArgs) { - CALL("EvaluateMonom::operator()(AnyPoly, PolyNf*)") - using Polynom = Kernel::Polynom; using Monom = Kernel::Monom; @@ -244,8 +236,6 @@ struct EvaluateMonom return perfect(Polynom( poly->iterSummands() .map([&](Monom m) -> Monom { - CALL("EvaluateMonom::clsr01") - auto result = eval(m, &evaluatedArgs[offs]); offs += m.factors->nFactors(); return result; @@ -255,7 +245,6 @@ struct EvaluateMonom PolyNf operator()(PolyNf term, PolyNf* evaluatedArgs) { - CALL("EvaluateMonom::operator()") return EvaluatePolynom{*this}(term, evaluatedArgs); } }; @@ -309,7 +298,6 @@ class FlatMeetLattice template Stack intersectSortedStack(Stack&& l, Stack&& r) { - CALL("intersectSortedStack") // DEBUG("lhs: ", l) // DEBUG("rhs: ", r) @@ -345,7 +333,6 @@ Stack intersectSortedStack(Stack&& l, Stack&& r) SimplifyingGeneratingInference1::Result AdditionGeneralization::simplify(Clause* cl, bool doOrderingCheck) { - CALL("AdditionGeneralization::simplify") return AdditionGeneralizationImpl::applyRule(cl,doOrderingCheck); } @@ -354,14 +341,12 @@ AdditionGeneralization::~AdditionGeneralization() {} SimplifyingGeneratingInference1::Result NumeralMultiplicationGeneralization::simplify(Clause* cl, bool doOrderingCheck) { - CALL("NumeralMultiplicationGeneralization::simplify") return NumeralMultiplicationGeneralizationImpl::applyRule(cl, doOrderingCheck); } NumeralMultiplicationGeneralization::~NumeralMultiplicationGeneralization() {} SimplifyingGeneratingInference1::Result VariableMultiplicationGeneralization::simplify(Clause* cl, bool doOrderingCheck) { - CALL("VariableMultiplicationGeneralization::simplify") return VariableMultiplicationGeneralizationImpl::applyRule(cl, doOrderingCheck); } @@ -370,7 +355,6 @@ VariableMultiplicationGeneralization::~VariableMultiplicationGeneralization() { SimplifyingGeneratingInference1::Result VariablePowerGeneralization::simplify(Clause* cl, bool doOrderingCheck) { - CALL("VariablePowerGeneralization::simplify") return VariablePowerGeneralizationImpl::applyRule(cl, doOrderingCheck); } diff --git a/Inferences/ArithmeticSubtermGeneralization/AdditionGeneralizationImpl.cpp b/Inferences/ArithmeticSubtermGeneralization/AdditionGeneralizationImpl.cpp index f8e6144d9..13ef2efc6 100644 --- a/Inferences/ArithmeticSubtermGeneralization/AdditionGeneralizationImpl.cpp +++ b/Inferences/ArithmeticSubtermGeneralization/AdditionGeneralizationImpl.cpp @@ -56,7 +56,6 @@ class MonomSet } MonomSet intersect(MonomSet&& rhs) && { - CALL("MonomSet::intersect") auto& lhs = *this; return MonomSet(intersectSortedStack(std::move(lhs._cancellable), std::move(rhs._cancellable))); } @@ -79,7 +78,6 @@ struct Preprocess template void operator()(Perfect> poly) { - CALL("AdditionGeneralizationImpl::Preprocess::operator()") // a variable might occur twice within one sum. Set didOccur; for (auto monom : poly->iterSummands()) { @@ -123,7 +121,6 @@ struct Generalize template Perfect> operator()(Perfect> poly, PolyNf* generalizedArgs) { - CALL("AdditionGeneralizationImpl::Generalize::operator()") using Monom = Kernel::Monom; auto found = poly->iterSummands() diff --git a/Inferences/ArithmeticSubtermGeneralization/NumeralMultiplicationGeneralizationImpl.cpp b/Inferences/ArithmeticSubtermGeneralization/NumeralMultiplicationGeneralizationImpl.cpp index b35f62b01..f08de22e4 100644 --- a/Inferences/ArithmeticSubtermGeneralization/NumeralMultiplicationGeneralizationImpl.cpp +++ b/Inferences/ArithmeticSubtermGeneralization/NumeralMultiplicationGeneralizationImpl.cpp @@ -48,7 +48,6 @@ struct Generalize template Monom operator()(Monom monom, PolyNf* evaluatedArgs) { - CALL("NumeralMultiplicationGeneralizationImpl::Generalize::operator()") using Monom = Monom; auto newFactors = perfect(monom.factors->replaceTerms(evaluatedArgs)); for (auto f : monom.factors->iter()) { diff --git a/Inferences/ArithmeticSubtermGeneralization/VariableMultiplicationGeneralizationImpl.cpp b/Inferences/ArithmeticSubtermGeneralization/VariableMultiplicationGeneralizationImpl.cpp index 9c233df0e..4b1adedc9 100644 --- a/Inferences/ArithmeticSubtermGeneralization/VariableMultiplicationGeneralizationImpl.cpp +++ b/Inferences/ArithmeticSubtermGeneralization/VariableMultiplicationGeneralizationImpl.cpp @@ -124,8 +124,6 @@ struct Preprocess template void operator()(Perfect> p) { - CALL("Preprocess::operator()") - for (auto summand : p->iterSummands()) { auto varIter = summand.factors->iter() @@ -162,7 +160,6 @@ struct Preprocess int joinRegions(int v, int w) { - CALL("Preprocess::joinRegions()") if (v == w) return v; components.doUnion(v,w); @@ -185,7 +182,6 @@ struct Generalize template Monom operator()(Monom p, PolyNf* evaluatedArgs) { - CALL("Generalize::operator()") using Pair = Monom; return Pair(p.numeral, perfect(MonomFactors(filter(p.factors, evaluatedArgs)))); } diff --git a/Inferences/ArrayTheoryISE.cpp b/Inferences/ArrayTheoryISE.cpp index f5a04c90c..dac33737f 100644 --- a/Inferences/ArrayTheoryISE.cpp +++ b/Inferences/ArrayTheoryISE.cpp @@ -42,8 +42,6 @@ ArrayTermTransformer::~ArrayTermTransformer() {} TermList ArrayTermTransformer::transformSubterm(TermList trm) { - CALL("ArrayTermTransformer::transformSubterm"); - if (!trm.isTerm()) { return trm; } @@ -122,8 +120,6 @@ TermList ArrayTermTransformer::transformSubterm(TermList trm) Literal* ArrayTermTransformer::rewriteNegEqByExtensionality(Literal* l) { - CALL("ArrayTermTransformer::rewriteNegEqByExtensionality"); - if (l->isEquality() && l->isNegative()) { unsigned sort = SortHelper::getEqualityArgumentSort(l); unsigned select = theory->getSymbolForStructuredSort(sort, Theory::StructuredSortInterpretation::ARRAY_SELECT); @@ -153,8 +149,6 @@ ArrayTheoryISE::ArrayTheoryISE() : Clause* ArrayTheoryISE::simplify(Clause* c) { - CALL("ArrayTheoryISE::simplify"); - if (c->inputType() == Unit::AXIOM) { return c; } diff --git a/Inferences/BackwardDemodulation.cpp b/Inferences/BackwardDemodulation.cpp index 69b531397..f03d7adca 100644 --- a/Inferences/BackwardDemodulation.cpp +++ b/Inferences/BackwardDemodulation.cpp @@ -52,7 +52,6 @@ using namespace Saturation; void BackwardDemodulation::attach(SaturationAlgorithm* salg) { - CALL("BackwardDemodulation::attach"); BackwardSimplificationEngine::attach(salg); _index=static_cast( _salg->getIndexManager()->request(DEMODULATION_SUBTERM_SUBST_TREE) ); @@ -60,7 +59,6 @@ void BackwardDemodulation::attach(SaturationAlgorithm* salg) void BackwardDemodulation::detach() { - CALL("BackwardDemodulation::detach"); _index=0; _salg->getIndexManager()->release(DEMODULATION_SUBTERM_SUBST_TREE); BackwardSimplificationEngine::detach(); @@ -108,8 +106,6 @@ struct BackwardDemodulation::ResultFn */ BwSimplificationRecord operator() (pair arg) { - CALL("BackwardDemodulation::ResultFn::operator()"); - TermQueryResult qr=arg.second; if( !ColorHelper::compatible(_cl->color(), qr.clause->color()) ) { @@ -235,7 +231,6 @@ struct BackwardDemodulation::ResultFn void BackwardDemodulation::perform(Clause* cl, BwSimplificationRecordIterator& simplifications) { - CALL("BackwardDemodulation::perform"); TIME_TRACE("backward demodulation"); if(cl->length()!=1 || !(*cl)[0]->isEquality() || !(*cl)[0]->isPositive() ) { diff --git a/Inferences/BackwardSubsumptionDemodulation.cpp b/Inferences/BackwardSubsumptionDemodulation.cpp index c2958ccc5..fbe7467c4 100644 --- a/Inferences/BackwardSubsumptionDemodulation.cpp +++ b/Inferences/BackwardSubsumptionDemodulation.cpp @@ -63,7 +63,6 @@ BackwardSubsumptionDemodulation::BackwardSubsumptionDemodulation() void BackwardSubsumptionDemodulation::attach(SaturationAlgorithm* salg) { - CALL("BackwardSubsumptionDemodulation::attach"); BackwardSimplificationEngine::attach(salg); _index.request(salg->getIndexManager(), BACKWARD_SUBSUMPTION_SUBST_TREE); @@ -72,7 +71,6 @@ void BackwardSubsumptionDemodulation::attach(SaturationAlgorithm* salg) void BackwardSubsumptionDemodulation::detach() { - CALL("BackwardSubsumptionDemodulation::detach"); _index.release(); BackwardSimplificationEngine::detach(); } @@ -113,7 +111,6 @@ STLIterator getSTLIterator(Iterator begin, Iterator end) void BackwardSubsumptionDemodulation::perform(Clause* sideCl, BwSimplificationRecordIterator& simplifications) { - CALL("BackwardSubsumptionDemodulation::perform"); ASSERT_VALID(*sideCl); TIME_TRACE("backward subsumption demodulation"); diff --git a/Inferences/BackwardSubsumptionResolution.cpp b/Inferences/BackwardSubsumptionResolution.cpp index 50c9732be..a7aaf6ff2 100644 --- a/Inferences/BackwardSubsumptionResolution.cpp +++ b/Inferences/BackwardSubsumptionResolution.cpp @@ -54,7 +54,6 @@ using namespace Saturation; void BackwardSubsumptionResolution::attach(SaturationAlgorithm* salg) { - CALL("BackwardSubsumptionResolution::attach"); BackwardSimplificationEngine::attach(salg); _index=static_cast( _salg->getIndexManager()->request(BACKWARD_SUBSUMPTION_SUBST_TREE) ); @@ -62,7 +61,6 @@ void BackwardSubsumptionResolution::attach(SaturationAlgorithm* salg) void BackwardSubsumptionResolution::detach() { - CALL("BackwardSubsumptionResolution::detach"); _index=0; _salg->getIndexManager()->release(BACKWARD_SUBSUMPTION_SUBST_TREE); BackwardSimplificationEngine::detach(); @@ -88,7 +86,6 @@ struct BackwardSubsumptionResolution::ClauseToBwSimplRecordFn void BackwardSubsumptionResolution::perform(Clause* cl, BwSimplificationRecordIterator& simplifications) { - CALL("BackwardSubsumptionResolution::perform"); ASSERT_VALID(*cl); //we do all work in this method, so we can just measure time simply diff --git a/Inferences/BinaryResolution.cpp b/Inferences/BinaryResolution.cpp index 4c31403b5..3589c2200 100644 --- a/Inferences/BinaryResolution.cpp +++ b/Inferences/BinaryResolution.cpp @@ -50,7 +50,6 @@ using namespace Saturation; void BinaryResolution::attach(SaturationAlgorithm* salg) { - CALL("BinaryResolution::attach"); ASS(!_index); GeneratingInferenceEngine::attach(salg); @@ -62,7 +61,6 @@ void BinaryResolution::attach(SaturationAlgorithm* salg) void BinaryResolution::detach() { - CALL("BinaryResolution::detach"); ASS(_salg); _index=0; @@ -97,8 +95,6 @@ struct BinaryResolution::ResultFn : _cl(cl), _passiveClauseContainer(passiveClauseContainer), _afterCheck(afterCheck), _ord(ord), _selector(selector), _parent(parent) {} Clause* operator()(pair arg) { - CALL("BinaryResolution::ResultFn::operator()"); - SLQueryResult& qr = arg.second; Literal* resLit = arg.first; @@ -119,7 +115,6 @@ struct BinaryResolution::ResultFn */ Clause* BinaryResolution::generateClause(Clause* queryCl, Literal* queryLit, SLQueryResult qr, const Options& opts, PassiveClauseContainer* passiveClauseContainer, Ordering* ord, LiteralSelector* ls) { - CALL("BinaryResolution::generateClause"); ASS(qr.clause->store()==Clause::ACTIVE);//Added to check that generation only uses active clauses if(!ColorHelper::compatible(queryCl->color(),qr.clause->color()) ) { @@ -319,8 +314,6 @@ Clause* BinaryResolution::generateClause(Clause* queryCl, Literal* queryLit, SLQ ClauseIterator BinaryResolution::generateClauses(Clause* premise) { - CALL("BinaryResolution::generateClauses"); - //cout << "BinaryResolution for " << premise->toString() << endl; PassiveClauseContainer* passiveClauseContainer = _salg->getPassiveClauseContainer(); diff --git a/Inferences/BoolEqToDiseq.cpp b/Inferences/BoolEqToDiseq.cpp index 4cbd3f42f..f7004cc91 100644 --- a/Inferences/BoolEqToDiseq.cpp +++ b/Inferences/BoolEqToDiseq.cpp @@ -44,8 +44,6 @@ typedef ApplicativeHelper AH; ClauseIterator BoolEqToDiseq::generateClauses(Clause* cl) { - CALL("PrimitiveInstantiation::generateClauses"); - unsigned pos = 0; Literal* newLit = 0; diff --git a/Inferences/BoolSimp.cpp b/Inferences/BoolSimp.cpp index eabbba590..52ed8dfb8 100644 --- a/Inferences/BoolSimp.cpp +++ b/Inferences/BoolSimp.cpp @@ -28,8 +28,6 @@ namespace Inferences { Clause* BoolSimp::simplify(Clause* premise) { - CALL("BoolSimp::simplify"); - TermList subTerm; TermList simpedSubTerm; unsigned literalPosition = 0; @@ -67,8 +65,6 @@ Clause* BoolSimp::simplify(Clause* premise) { } bool BoolSimp::areComplements(TermList t1, TermList t2){ - CALL("BoolSimp::areComplements"); - Signature::Symbol* sym; static TermStack args; TermList head; @@ -96,8 +92,6 @@ bool BoolSimp::areComplements(TermList t1, TermList t2){ TermList BoolSimp::negate(TermList term){ - CALL("BoolSimp::negate"); - TermList constant, constSort; constant = TermList(Term::createConstant(env.signature->getNotProxy())); @@ -106,8 +100,6 @@ TermList BoolSimp::negate(TermList term){ } TermList BoolSimp::boolSimplify(TermList term){ - CALL("BoolSimp::boolSimplify"); - static TermList troo(Term::foolTrue()); static TermList fols(Term::foolFalse()); static TermStack args; diff --git a/Inferences/CNFOnTheFly.cpp b/Inferences/CNFOnTheFly.cpp index e493d2e81..99d8f6acf 100644 --- a/Inferences/CNFOnTheFly.cpp +++ b/Inferences/CNFOnTheFly.cpp @@ -44,8 +44,6 @@ static ClauseIterator produceClauses(Clause* c, bool generating, SkolemisingForm typedef ApplicativeHelper AH; /*Clause* NotProxyISE::simplify(Clause* c){ - CALL("NotProxyISE::simplify"); - TermList boolSort = AtomicSort::boolSort(); TermList troo = TermList(Term::foolTrue()); TermList fols = TermList(Term::foolFalse()); @@ -88,8 +86,6 @@ typedef ApplicativeHelper AH; } Clause* EqualsProxyISE::simplify(Clause* c){ - CALL("EqualsProxyISE::simplify"); - TermList boolSort = AtomicSort::boolSort(); TermList troo = TermList(Term::foolTrue()); TermList fols = TermList(Term::foolFalse()); @@ -132,8 +128,6 @@ Clause* EqualsProxyISE::simplify(Clause* c){ } Clause* PiSigmaProxyISE::simplify(Clause* c){ - CALL("PiSigmaProxyISE::simplify"); - TermList boolSort = AtomicSort::boolSort(); TermList troo = TermList(Term::foolTrue()); TermList fols = TermList(Term::foolFalse()); @@ -187,8 +181,6 @@ Clause* PiSigmaProxyISE::simplify(Clause* c){ } Clause* OrImpAndProxyISE::simplify(Clause* c){ - CALL("rImpAndProxyISE::simplify"); - TermList boolSort = AtomicSort::boolSort(); TermList troo = TermList(Term::foolTrue()); TermList fols = TermList(Term::foolFalse()); @@ -255,8 +247,6 @@ Clause* OrImpAndProxyISE::simplify(Clause* c){ } ClauseIterator ProxyISE::simplifyMany(Clause* c){ - CALL("ProxyISE::simplifyMany"); - TermList troo = TermList(Term::foolTrue()); TermList fols = TermList(Term::foolFalse()); TermList boolSort = AtomicSort::boolSort(); @@ -405,8 +395,6 @@ ClauseIterator ProxyISE::simplifyMany(Clause* c){ ClauseIterator produceClauses(Clause* c, bool generating, SkolemisingFormulaIndex* index) { - CALL("CNFOnTheFly::produceClauses"); - static bool eager = env.options->cnfOnTheFly() == Options::CNFOnTheFly::EAGER; static bool simp = env.options->cnfOnTheFly() == Options::CNFOnTheFly::LAZY_SIMP; static bool gen = env.options->cnfOnTheFly() == Options::CNFOnTheFly::LAZY_GEN; @@ -595,8 +583,6 @@ ClauseIterator produceClauses(Clause* c, bool generating, SkolemisingFormulaInde Clause* replaceLits(Clause *c, Literal *a, Literal *b, InferenceRule r, bool incAge, Literal *d, Literal* e) { - CALL("CNFOnTheFly::replaceLits"); - int length = c->length(); if(d){ length++;} if(e){ length++;} @@ -617,8 +603,6 @@ Clause* replaceLits(Clause *c, Literal *a, Literal *b, InferenceRule r, bool inc } InferenceRule convert(Signature::Proxy cnst){ - CALL("CNFOnTheFly::convert"); - switch(cnst){ case Signature::PI: return InferenceRule::VPI_ELIMINATION; @@ -634,8 +618,6 @@ InferenceRule convert(Signature::Proxy cnst){ } TermList sigmaRemoval(TermList sigmaTerm, TermList expsrt){ - CALL("CNFOnTheFly::sigmaRemoval"); - static DHMap varSorts; varSorts.reset(); @@ -696,8 +678,6 @@ TermList sigmaRemoval(TermList sigmaTerm, TermList expsrt){ TermList piRemoval(TermList piTerm, Clause* clause, TermList expsrt){ - CALL("CNFOnTheFly::piRemoval"); - unsigned maxVar = clause->maxVar(); do{ maxVar++; @@ -711,8 +691,6 @@ TermList piRemoval(TermList piTerm, Clause* clause, TermList expsrt){ Clause* IFFXORRewriterISE::simplify(Clause* c){ - CALL("IFFXORRewriterISE::simplify"); - TermList boolSort = AtomicSort::boolSort(); static TermStack args; @@ -752,8 +730,6 @@ Clause* IFFXORRewriterISE::simplify(Clause* c){ void LazyClausificationGIE::attach(SaturationAlgorithm* salg) { - CALL("LazyClausificationGIE::attach"); - GeneratingInferenceEngine::attach(salg); _formulaIndex=static_cast ( _salg->getIndexManager()->request(SKOLEMISING_FORMULA_INDEX) ); @@ -761,8 +737,6 @@ void LazyClausificationGIE::attach(SaturationAlgorithm* salg) void LazyClausificationGIE::detach() { - CALL("LazyClausificationGIE::detach"); - _formulaIndex=0; _salg->getIndexManager()->release(SKOLEMISING_FORMULA_INDEX); GeneratingInferenceEngine::detach(); @@ -770,8 +744,6 @@ void LazyClausificationGIE::detach() void LazyClausification::attach(SaturationAlgorithm* salg) { - CALL("LazyClausification::attach"); - SimplificationEngine::attach(salg); _formulaIndex=static_cast ( _salg->getIndexManager()->request(SKOLEMISING_FORMULA_INDEX) ); @@ -779,8 +751,6 @@ void LazyClausification::attach(SaturationAlgorithm* salg) void LazyClausification::detach() { - CALL("LazyClausification::detach"); - _formulaIndex=0; _salg->getIndexManager()->release(SKOLEMISING_FORMULA_INDEX); SimplificationEngine::detach(); @@ -788,22 +758,16 @@ void LazyClausification::detach() ClauseIterator EagerClausificationISE::simplifyMany(Clause* c) { - CALL("EagerClausificationISE::simplifyMany"); - return produceClauses(c, false); } ClauseIterator LazyClausificationGIE::generateClauses(Clause* c) { - CALL("LazyClausificationGIE::simplifyMany"); - return produceClauses(c, true, _formulaIndex); } ClauseIterator LazyClausification::perform(Clause* c) { - CALL("LazyClausification::perform"); - return produceClauses(c, false, _formulaIndex); } diff --git a/Inferences/Cancellation.cpp b/Inferences/Cancellation.cpp index 67fc7b8e2..90a08e7f1 100644 --- a/Inferences/Cancellation.cpp +++ b/Inferences/Cancellation.cpp @@ -32,7 +32,6 @@ CancelAddResult cancelAdd(Polynom const& oldl, Polynom c template Literal* cancelAdd(Literal* lit) { - CALL("cancelAdd(Literal* lit)") ASS_EQ(lit->numTypeArguments(), 0) // <- we only have equality, or inequality literals, which are not polymorphic ASS_EQ(lit->numTermArguments(), 2) auto normL = PolyNf::normalize(TypedTermList((*lit)[0], SortHelper::getTermArgSort(lit, 0))); @@ -60,7 +59,6 @@ Literal* cancelAdd(Literal* lit) { } Literal* tryCancel(Interpretation inter, Literal* lit) { - CALL("tryCancel(Interpretation inter, Literal* lit)") switch(inter) { case Interpretation::EQUAL: { auto sort = SortHelper::getEqualityArgumentSort(lit); @@ -89,8 +87,6 @@ Cancellation::Cancellation(Ordering& ordering) : SimplifyingGeneratingLiteralSim Cancellation::Result Cancellation::simplifyLiteral(Literal* litIn) { - CALL("Cancellation::simplifyLiteral(Literal*)") - auto pred = litIn->functor(); return Result::literal( theory->isInterpretedPredicate(pred) @@ -101,7 +97,6 @@ Cancellation::Result Cancellation::simplifyLiteral(Literal* litIn) template CancelAddResult cancelAdd(Polynom const& oldl, Polynom const& oldr) { - CALL("Polynom::cancelAdd(Polynom const& oldl, Polynom const& oldr)") DEBUG("in: ", oldl, " <> ", oldr) using Numeral = typename Number::ConstantType; diff --git a/Inferences/Cases.cpp b/Inferences/Cases.cpp index 9e60675f6..6c085246a 100644 --- a/Inferences/Cases.cpp +++ b/Inferences/Cases.cpp @@ -35,8 +35,6 @@ namespace Inferences { Clause* Cases::performParamodulation(Clause* premise, Literal* lit, TermList t) { - CALL("Cases::performParamodulation"); - ASS(t.isTerm()); TermList lhs = *lit->nthArgument(0); @@ -79,8 +77,6 @@ struct Cases::ResultFn ResultFn(Clause* cl, Cases& parent) : _cl(cl), _parent(parent) {} Clause* operator()(pair arg) { - CALL("FOOLParamodulation::ResultFn::operator()"); - return _parent.performParamodulation(_cl, arg.first, arg.second); } private: @@ -94,8 +90,6 @@ struct Cases::RewriteableSubtermsFn VirtualIterator > operator()(Literal* lit) { - CALL("Cases::RewriteableSubtermsFn()"); - return pvi( pushPairIntoRightIterator(lit, EqHelper::getBooleanSubtermIterator(lit, _ord)) ); } @@ -106,8 +100,6 @@ struct Cases::RewriteableSubtermsFn ClauseIterator Cases::generateClauses(Clause* premise) { - CALL("Cases::generateClauses"); - auto it1 = premise->getSelectedLiteralIterator(); auto it2 = getMapAndFlattenIterator(it1,RewriteableSubtermsFn(_salg->getOrdering())); diff --git a/Inferences/CasesSimp.cpp b/Inferences/CasesSimp.cpp index 587b3221f..e39caa59c 100644 --- a/Inferences/CasesSimp.cpp +++ b/Inferences/CasesSimp.cpp @@ -36,8 +36,6 @@ namespace Inferences { ClauseIterator CasesSimp::performSimplification(Clause* premise, Literal* lit, TermList t) { - CALL("CasesSimp::performSimplification"); - ASS(t.isTerm()); static ClauseStack results; @@ -91,8 +89,6 @@ struct CasesSimp::ResultFn ResultFn(Clause* cl, CasesSimp& parent) : _cl(cl), _parent(parent) {} ClauseIterator operator()(pair arg) { - CALL("CasesSimp::ResultFn::operator()"); - return _parent.performSimplification(_cl, arg.first, arg.second); } private: @@ -106,8 +102,6 @@ struct CasesSimp::RewriteableSubtermsFn VirtualIterator > operator()(Literal* lit) { - CALL("CasesSimp::RewriteableSubtermsFn()"); - return pvi( pushPairIntoRightIterator(lit, getUniquePersistentIterator(vi(new BooleanSubtermIt(lit))))); } @@ -117,8 +111,6 @@ struct CasesSimp::RewriteableSubtermsFn ClauseIterator CasesSimp::simplifyMany(Clause* premise) { - CALL("CasesSimp::generateClauses"); - auto it1 = premise->getLiteralIterator(); auto it2 = getFilteredIterator(it1, isEqualityLit()); diff --git a/Inferences/Choice.cpp b/Inferences/Choice.cpp index b9c045ee7..41d2a09a1 100644 --- a/Inferences/Choice.cpp +++ b/Inferences/Choice.cpp @@ -46,8 +46,6 @@ using namespace Saturation; Clause* Choice::createChoiceAxiom(TermList op, TermList set) { - CALL("Choice::createChoiceAxiom"); - TermList opType = SortHelper::getResultSort(op.term()); TermList setType = ApplicativeHelper::getNthArg(opType, 1); @@ -77,8 +75,6 @@ struct Choice::AxiomsIterator { AxiomsIterator(Term* term) { - CALL("Choice::AxiomsIterator"); - _set = *term->nthArgument(3); _headSort = AtomicSort::arrowSort(*term->nthArgument(0),*term->nthArgument(1)); _resultSort = ApplicativeHelper::getResultApplieadToNArgs(_headSort, 1); @@ -94,8 +90,6 @@ struct Choice::AxiomsIterator DECL_ELEMENT_TYPE(Clause*); bool hasNext() { - CALL("Choice::AxiomsIterator::hasNext()"); - if(_inBetweenNextandHasNext){ return true; } while(!_choiceOps.isEmpty()){ @@ -128,7 +122,6 @@ struct Choice::AxiomsIterator OWN_ELEMENT_TYPE next() { - CALL("Choice::AxiomsIterator::next()"); _inBetweenNextandHasNext = false; Clause* c = createChoiceAxiom(_opApplied, _setApplied); env.statistics->choiceInstances++; @@ -194,8 +187,6 @@ struct Choice::SubtermsFn VirtualIterator operator()(Literal* lit) { - CALL("Choice::RewriteableSubtermsFn()"); - NonVariableNonTypeIterator nvi(lit); return pvi(getUniquePersistentIteratorFromPtr(&nvi)); } @@ -203,8 +194,6 @@ struct Choice::SubtermsFn ClauseIterator Choice::generateClauses(Clause* premise) { - CALL("PrimitiveInstantiation::generateClauses"); - //cout << "Choice with " << premise->toString() << endl; //is this correct? diff --git a/Inferences/CombinatorDemodISE.cpp b/Inferences/CombinatorDemodISE.cpp index 358de9c4c..14b6ea286 100644 --- a/Inferences/CombinatorDemodISE.cpp +++ b/Inferences/CombinatorDemodISE.cpp @@ -35,8 +35,6 @@ typedef ApplicativeHelper AH; Clause* CombinatorDemodISE::simplify(Clause* c) { - CALL("CombinatorDemodISE::simplify"); - Literal* newLit; LiteralStack litStack; bool modified = false; @@ -86,8 +84,6 @@ Clause* CombinatorDemodISE::simplify(Clause* c) TermList CombinatorDemodISE::reduce(TermList t, unsigned& length) { - CALL("CombinatorDemodISE::reduce"); - typedef SmartPtr ArgsIt_ptr; ASS(!t.isVar()); @@ -174,8 +170,6 @@ TermList CombinatorDemodISE::reduce(TermList t, unsigned& length) bool CombinatorDemodISE::headNormalForm(TermList& t) { - CALL("CombinatorDemodISE::headNormalForm"); - static TermStack args; TermList head; diff --git a/Inferences/CombinatorNormalisationISE.cpp b/Inferences/CombinatorNormalisationISE.cpp index 8c2dcb838..31aa0819d 100644 --- a/Inferences/CombinatorNormalisationISE.cpp +++ b/Inferences/CombinatorNormalisationISE.cpp @@ -36,8 +36,6 @@ typedef ApplicativeHelper AH; Clause* CombinatorNormalisationISE::simplify(Clause* c) { - CALL("CombinatorNormalisationISE::simplify"); - Literal* newLit; LiteralStack litStack; bool modified = false; @@ -73,8 +71,6 @@ Clause* CombinatorNormalisationISE::simplify(Clause* c) TermList CombinatorNormalisationISE::normalise(TermList t) { - CALL("CombinatorNormalisationISE::normalise"); - typedef SmartPtr ArgsIt_ptr; ASS(!t.isVar()); @@ -162,8 +158,6 @@ TermList CombinatorNormalisationISE::normalise(TermList t) bool CombinatorNormalisationISE::replaceWithSmallerCombinator(TermList& t) { - CALL("CombinatorNormalisationISE::replaceWithSmallerCombinator"); - static TermStack args; static TermStack args1; static TermStack args2; @@ -306,8 +300,6 @@ bool CombinatorNormalisationISE::replaceWithSmallerCombinator(TermList& t) TermList CombinatorNormalisationISE::createKTerm(TermList s1, TermList s2, TermList arg1) { - CALL("CombinatorNormalisationISE::createKTerm"); - unsigned kcomb = env.signature->getCombinator(Signature::K_COMB); TermList res = TermList(Term::create2(kcomb, s1, s2)); res = AH::createAppTerm(SortHelper::getResultSort(res.term()), res, arg1); @@ -317,8 +309,6 @@ TermList CombinatorNormalisationISE::createKTerm(TermList s1, TermList s2, TermL TermList CombinatorNormalisationISE::createSCorBTerm(TermList arg1, TermList arg1sort, TermList arg2, TermList arg2sort, Signature::Combinator comb) { - CALL("CombinatorNormalisationISE::createSCorBTerm"); - TermList s1, s2, s3; unsigned cb = env.signature->getCombinator(comb); diff --git a/Inferences/Condensation.cpp b/Inferences/Condensation.cpp index 0bdc78b50..60c63f119 100644 --- a/Inferences/Condensation.cpp +++ b/Inferences/Condensation.cpp @@ -42,7 +42,6 @@ using namespace Saturation; Clause* Condensation::simplify(Clause* cl) { - CALL("Condensation::perform"); TIME_TRACE("condensation"); unsigned clen=cl->length(); diff --git a/Inferences/DefinitionIntroduction.cpp b/Inferences/DefinitionIntroduction.cpp index a635e3da8..ff4de246c 100644 --- a/Inferences/DefinitionIntroduction.cpp +++ b/Inferences/DefinitionIntroduction.cpp @@ -28,7 +28,6 @@ static Stack args; static DHMap, unsigned> substitution; Term *DefinitionIntroduction::lgg(Term *left, Term *right) { - CALL("DefinitionIntroduction::lgg") ASS_EQ(left->functor(), right->functor()) ASS_EQ(functions.length(), 0) ASS_EQ(args.length(), 0) @@ -84,8 +83,6 @@ Term *DefinitionIntroduction::lgg(Term *left, Term *right) { } void DefinitionIntroduction::introduceDefinitionFor(Term *t) { - CALL("DefinitionIntroduction::introduceDefinitionFor"); - if(!_defined.insert(t)) return; @@ -117,8 +114,6 @@ void DefinitionIntroduction::introduceDefinitionFor(Term *t) { } void DefinitionIntroduction::process(Term *t) { - CALL("DefinitionIntroduction::process(Term *)"); - unsigned functor = t->functor(); Stack &entries = _entries[functor]; @@ -144,8 +139,6 @@ void DefinitionIntroduction::process(Term *t) { } void DefinitionIntroduction::process(Clause *cl) { - CALL("DefinitionIntroduction::process(Clause *)"); - if(cl->inference().rule() == InferenceRule::FUNCTION_DEFINITION) return; diff --git a/Inferences/DefinitionIntroduction.hpp b/Inferences/DefinitionIntroduction.hpp index 59dc56d8d..290c93cc9 100644 --- a/Inferences/DefinitionIntroduction.hpp +++ b/Inferences/DefinitionIntroduction.hpp @@ -27,14 +27,12 @@ class DefinitionIntroduction: public GeneratingInferenceEngine, public Index { USE_ALLOCATOR(DefinitionIntroduction); void attach(SaturationAlgorithm *salg) override { - CALL("DefinitionIntroduction::attach") GeneratingInferenceEngine::attach(salg); attachContainer(salg->getPassiveClauseContainer()); reset = false; } void handleClause(Clause *cl, bool adding) override { - CALL("DefinitionIntroduction::handleClause"); if(reset) _definitions.reset(); @@ -44,7 +42,6 @@ class DefinitionIntroduction: public GeneratingInferenceEngine, public Index { } ClauseIterator generateClauses(Clause *cl) override { - CALL("DefinitionIntroduction::generateClauses"); reset = true; return pvi(decltype(_definitions)::Iterator(_definitions)); } diff --git a/Inferences/DistinctEqualitySimplifier.cpp b/Inferences/DistinctEqualitySimplifier.cpp index 1130ed1ee..ca4d6773d 100644 --- a/Inferences/DistinctEqualitySimplifier.cpp +++ b/Inferences/DistinctEqualitySimplifier.cpp @@ -25,8 +25,6 @@ namespace Inferences Clause* DistinctEqualitySimplifier::simplify(Clause* cl) { - CALL("DistinctEqualitySimplifier::simplify"); - if(!canSimplify(cl)) { return cl; } @@ -69,16 +67,12 @@ Clause* DistinctEqualitySimplifier::simplify(Clause* cl) bool DistinctEqualitySimplifier::mustBeDistinct(TermList t1, TermList t2) { - CALL("DistinctEqualitySimplifier::mustBeDistinct/2"); - unsigned aux; return mustBeDistinct(t1, t2, aux); } bool DistinctEqualitySimplifier::mustBeDistinct(TermList t1, TermList t2, unsigned& grp) { - CALL("DistinctEqualitySimplifier::mustBeDistinct/3"); - if(!t1.isTerm() || t1.term()->arity()!=0 || !t2.isTerm() || t2.term()->arity()!=0 || t1.term() == t2.term()) { return false; } @@ -105,8 +99,6 @@ bool DistinctEqualitySimplifier::mustBeDistinct(TermList t1, TermList t2, unsign bool DistinctEqualitySimplifier::canSimplify(Clause* cl) { - CALL("DistinctEqualitySimplifier::canSimplify"); - unsigned clen = cl->length(); for(unsigned i=0; inthArgument(0); TermList rhs = *lit->nthArgument(1); ASS(AH::isBool(lhs) || AH::isBool(rhs)); @@ -58,7 +56,6 @@ bool ElimLeibniz::polarity(Literal* lit) { } bool ElimLeibniz::isPair(Literal* l1, Literal* l2){ - CALL("ElimLeibniz::isPair"); ASS(polarity(l1) != polarity(l2)); LeibEqRec ler1 = getLiteralInfo(l1); @@ -67,8 +64,6 @@ bool ElimLeibniz::isPair(Literal* l1, Literal* l2){ } ElimLeibniz::LeibEqRec ElimLeibniz::getLiteralInfo(Literal* lit){ - CALL("ElimLeibniz::getLiteralInfo"); - TermList lhs = *lit->nthArgument(0); TermList rhs = *lit->nthArgument(1); TermList nonBooleanSide = AH::isBool(rhs) ? lhs : rhs; @@ -85,8 +80,6 @@ ElimLeibniz::LeibEqRec ElimLeibniz::getLiteralInfo(Literal* lit){ Clause* ElimLeibniz::createConclusion(Clause* premise, Literal* newLit, Literal* posLit, Literal* negLit, RobSubstitution& subst){ - CALL("ElimLeibniz::createConclusion"); - unsigned newLen=premise->length() - 1; Clause* res = new(newLen) Clause(newLen, GeneratingInference1(InferenceRule::LEIBNIZ_ELIMINATION, premise)); Literal* newLitAfter = subst.apply(newLit, 0); @@ -106,8 +99,6 @@ Clause* ElimLeibniz::createConclusion(Clause* premise, Literal* newLit, ClauseIterator ElimLeibniz::generateClauses(Clause* premise) { - CALL("ElimLeibniz::generateClauses"); - typedef SortHelper SH; static TermStack args; diff --git a/Inferences/EqualityFactoring.cpp b/Inferences/EqualityFactoring.cpp index cd8164655..3660858ad 100644 --- a/Inferences/EqualityFactoring.cpp +++ b/Inferences/EqualityFactoring.cpp @@ -87,8 +87,6 @@ struct EqualityFactoring::ResultFn : _cl(cl), _cLen(cl->length()), _afterCheck(afterCheck), _ordering(ordering) {} Clause* operator() (pair,pair > arg) { - CALL("EqualityFactoring::ResultFn::operator()"); - Literal* sLit=arg.first.first; // selected literal ( = factored-out literal ) Literal* fLit=arg.second.first; // fairly boring side literal ASS(sLit->isEquality()); @@ -201,8 +199,6 @@ struct EqualityFactoring::ResultFn ClauseIterator EqualityFactoring::generateClauses(Clause* premise) { - CALL("EqualityFactoring::generateClauses"); - if(premise->length()<=1) { return ClauseIterator::getEmpty(); } diff --git a/Inferences/EqualityResolution.cpp b/Inferences/EqualityResolution.cpp index 1c231943d..aed6d3ef8 100644 --- a/Inferences/EqualityResolution.cpp +++ b/Inferences/EqualityResolution.cpp @@ -64,8 +64,6 @@ struct EqualityResolution::ResultFn : _afterCheck(afterCheck), _ord(ord), _cl(cl), _cLen(cl->length()) {} Clause* operator() (Literal* lit) { - CALL("EqualityResolution::ResultFn::operator()"); - ASS(lit->isEquality()); ASS(lit->isNegative()); @@ -192,8 +190,6 @@ struct EqualityResolution::ResultFn ClauseIterator EqualityResolution::generateClauses(Clause* premise) { - CALL("EqualityResolution::generateClauses"); - if(premise->isEmpty()) { return ClauseIterator::getEmpty(); } @@ -219,8 +215,6 @@ ClauseIterator EqualityResolution::generateClauses(Clause* premise) */ Clause* EqualityResolution::tryResolveEquality(Clause* cl, Literal* toResolve) { - CALL("EqualityResolution::tryResolveEquality"); - return ResultFn(cl)(toResolve); } diff --git a/Inferences/EquationalTautologyRemoval.cpp b/Inferences/EquationalTautologyRemoval.cpp index 4f1acf8ec..586b687df 100644 --- a/Inferences/EquationalTautologyRemoval.cpp +++ b/Inferences/EquationalTautologyRemoval.cpp @@ -24,8 +24,6 @@ namespace Inferences Clause* EquationalTautologyRemoval::simplify(Clause* cl) { - CALL("EquationalTautologyRemoval::simplify"); - // first check whether it makes sense to trigger CC: // 1) there should be at least one negative equality and // 2a) there should also be a positive one or diff --git a/Inferences/ExtensionalityResolution.cpp b/Inferences/ExtensionalityResolution.cpp index 7b29e607a..fc143934a 100644 --- a/Inferences/ExtensionalityResolution.cpp +++ b/Inferences/ExtensionalityResolution.cpp @@ -53,8 +53,6 @@ struct ExtensionalityResolution::ForwardPairingFn : _extClauses(extClauses) {} VirtualIterator > operator()(Literal* lit) { - CALL("ExtensionalityResolution::ForwardPairingFn::operator()"); - if (!lit->isEquality() || lit->isPositive()) { return VirtualIterator >::getEmpty(); } @@ -79,8 +77,6 @@ struct ExtensionalityResolution::ForwardUnificationsFn ForwardUnificationsFn() { _subst = RobSubstitutionSP(new RobSubstitution()); } VirtualIterator, RobSubstitution*> > operator()(pair arg) { - CALL("ExtensionalityResolution::ForwardUnificationsFn::operator()"); - Literal* trmEq = arg.first; Literal* varEq = arg.second.literal; @@ -102,8 +98,6 @@ struct ExtensionalityResolution::ForwardResultFn ForwardResultFn(Clause* otherCl, ExtensionalityResolution& parent) : _otherCl(otherCl), _parent(parent) {} Clause* operator()(pair, RobSubstitution*> arg) { - CALL("ExtensionalityResolution::ForwardResultFn::operator()"); - RobSubstitution* subst = arg.second; Literal* otherLit = arg.first.first; Clause* extCl = arg.first.second.clause; @@ -128,8 +122,6 @@ struct ExtensionalityResolution::NegEqSortFn NegEqSortFn (TermList sort) : _sort(sort) {} bool operator()(Literal* lit) { - CALL("ExtensionalityResolution::NegEqSortFn::operator()"); - return lit->isEquality() && lit->isNegative() && SortHelper::getEqualityArgumentSort(lit) == _sort; } @@ -146,8 +138,6 @@ struct ExtensionalityResolution::BackwardPairingFn BackwardPairingFn (TermList sort) : _sort(sort) {} VirtualIterator > operator()(Clause* cl) { - CALL("ExtensionalityResolution::BackwardPairingFn::operator()"); - return pvi(pushPairIntoRightIterator( cl, getFilteredIterator( @@ -169,8 +159,6 @@ struct ExtensionalityResolution::BackwardUnificationsFn : _extLit (extLit) { _subst = RobSubstitutionSP(new RobSubstitution()); } VirtualIterator, RobSubstitution*> > operator()(pair arg) { - CALL("ExtensionalityResolution::BackwardUnificationsFn::operator()"); - Literal* otherLit = arg.second; SubstIterator unifs = _subst->unifiers(_extLit,0,otherLit,1,true); @@ -192,8 +180,6 @@ struct ExtensionalityResolution::BackwardResultFn BackwardResultFn(Clause* extCl, Literal* extLit, ExtensionalityResolution& parent) : _extCl(extCl), _extLit(extLit), _parent(parent) {} Clause* operator()(pair, RobSubstitution*> arg) { - CALL("ExtensionalityResolution::BackwardResultFn::operator()"); - RobSubstitution* subst = arg.second; Clause* otherCl = arg.first.first; Literal* otherLit = arg.first.second; @@ -221,8 +207,6 @@ Clause* ExtensionalityResolution::performExtensionalityResolution( unsigned& counter, const Options& opts) { - CALL("ExtensionalityResolution::performExtensionalityResolution"); - if(!ColorHelper::compatible(extCl->color(),otherCl->color()) ) { env.statistics->inferencesSkippedDueToColors++; if(opts.showBlocked()) { @@ -267,8 +251,6 @@ Clause* ExtensionalityResolution::performExtensionalityResolution( */ ClauseIterator ExtensionalityResolution::generateClauses(Clause* premise) { - CALL("ExtensionalityResolution::generateClauses"); - ExtensionalityClauseContainer* extClauses = _salg->getExtensionalityClauseContainer(); ClauseIterator backwardIterator; diff --git a/Inferences/FOOLParamodulation.cpp b/Inferences/FOOLParamodulation.cpp index 1e899ca48..122225fbe 100644 --- a/Inferences/FOOLParamodulation.cpp +++ b/Inferences/FOOLParamodulation.cpp @@ -32,8 +32,6 @@ namespace Inferences { ClauseIterator FOOLParamodulation::generateClauses(Clause* premise) { - CALL("FOOLParamodulation::generateClauses"); - /** * We are going to implement the following inference rule, taken from the paper: * diff --git a/Inferences/Factoring.cpp b/Inferences/Factoring.cpp index 8b2b1bab4..36c77f156 100644 --- a/Inferences/Factoring.cpp +++ b/Inferences/Factoring.cpp @@ -59,8 +59,6 @@ class Factoring::UnificationsOnPositiveFn } VirtualIterator > operator() (pair nums) { - CALL("Factoring::UnificationsFn::operator()"); - Literal* l1 = (*_cl)[nums.first]; Literal* l2 = (*_cl)[nums.second]; @@ -106,8 +104,6 @@ class Factoring::ResultsFn : _cl(cl), _cLen(cl->length()), _afterCheck(afterCheck), _ord(ord) {} Clause* operator() (pair arg) { - CALL("Factoring::ResultsFn::operator()"); - unsigned newLength = _cLen-1; Clause* res = new(newLength) Clause(newLength, GeneratingInference1(InferenceRule::FACTORING,_cl)); @@ -171,8 +167,6 @@ class Factoring::ResultsFn */ ClauseIterator Factoring::generateClauses(Clause* premise) { - CALL("Factoring::generateClauses"); - if(premise->length()<=1) { return ClauseIterator::getEmpty(); } diff --git a/Inferences/FastCondensation.cpp b/Inferences/FastCondensation.cpp index a7029a76c..060afe407 100644 --- a/Inferences/FastCondensation.cpp +++ b/Inferences/FastCondensation.cpp @@ -48,8 +48,6 @@ struct FastCondensation::CondensationBinder } bool bind(unsigned var, TermList term) { - CALL("CondensationBinder::bind"); - if(varMap->get(var)==-1) { return term.isVar() && var==term.var(); } @@ -69,8 +67,6 @@ struct FastCondensation::CondensationBinder Clause* FastCondensation::simplify(Clause* cl) { - CALL("FastCondensation::perform"); - TIME_TRACE("fast condensation"); unsigned clen=cl->length(); diff --git a/Inferences/ForwardDemodulation.cpp b/Inferences/ForwardDemodulation.cpp index 71d384eb3..192ccdd58 100644 --- a/Inferences/ForwardDemodulation.cpp +++ b/Inferences/ForwardDemodulation.cpp @@ -53,7 +53,6 @@ using namespace Saturation; void ForwardDemodulation::attach(SaturationAlgorithm* salg) { - CALL("ForwardDemodulation::attach"); ForwardSimplificationEngine::attach(salg); _index=static_cast( _salg->getIndexManager()->request(DEMODULATION_LHS_CODE_TREE) ); @@ -65,7 +64,6 @@ void ForwardDemodulation::attach(SaturationAlgorithm* salg) void ForwardDemodulation::detach() { - CALL("ForwardDemodulation::detach"); _index=0; _salg->getIndexManager()->release(DEMODULATION_LHS_CODE_TREE); ForwardSimplificationEngine::detach(); @@ -74,7 +72,6 @@ void ForwardDemodulation::detach() template bool ForwardDemodulationImpl::perform(Clause* cl, Clause*& replacement, ClauseIterator& premises) { - CALL("ForwardDemodulation::perform"); TIME_TRACE("forward demodulation"); Ordering& ordering = _salg->getOrdering(); diff --git a/Inferences/ForwardLiteralRewriting.cpp b/Inferences/ForwardLiteralRewriting.cpp index 5222775a1..72bf7d567 100644 --- a/Inferences/ForwardLiteralRewriting.cpp +++ b/Inferences/ForwardLiteralRewriting.cpp @@ -29,7 +29,6 @@ namespace Inferences void ForwardLiteralRewriting::attach(SaturationAlgorithm* salg) { - CALL("ForwardLiteralRewriting::attach"); ForwardSimplificationEngine::attach(salg); _index=static_cast( _salg->getIndexManager()->request(REWRITE_RULE_SUBST_TREE) ); @@ -37,7 +36,6 @@ void ForwardLiteralRewriting::attach(SaturationAlgorithm* salg) void ForwardLiteralRewriting::detach() { - CALL("ForwardLiteralRewriting::detach"); _index=0; _salg->getIndexManager()->release(REWRITE_RULE_SUBST_TREE); ForwardSimplificationEngine::detach(); @@ -46,8 +44,6 @@ void ForwardLiteralRewriting::detach() bool ForwardLiteralRewriting::perform(Clause* cl, Clause*& replacement, ClauseIterator& premises) { - CALL("ForwardLiteralRewriting::perform"); - Ordering& ordering = _salg->getOrdering(); TIME_TRACE("forward literal rewriting"); diff --git a/Inferences/ForwardSubsumptionAndResolution.cpp b/Inferences/ForwardSubsumptionAndResolution.cpp index 0f6ff647f..57ec4825c 100644 --- a/Inferences/ForwardSubsumptionAndResolution.cpp +++ b/Inferences/ForwardSubsumptionAndResolution.cpp @@ -46,7 +46,6 @@ using namespace Saturation; void ForwardSubsumptionAndResolution::attach(SaturationAlgorithm *salg) { - CALL("ForwardSubsumptionAndResolution::attach"); ForwardSimplificationEngine::attach(salg); _unitIndex = static_cast( _salg->getIndexManager()->request(FW_SUBSUMPTION_UNIT_CLAUSE_SUBST_TREE)); @@ -56,7 +55,6 @@ void ForwardSubsumptionAndResolution::attach(SaturationAlgorithm *salg) void ForwardSubsumptionAndResolution::detach() { - CALL("ForwardSubsumptionAndResolution::detach"); _unitIndex = 0; _fwIndex = 0; _salg->getIndexManager()->release(FW_SUBSUMPTION_UNIT_CLAUSE_SUBST_TREE); @@ -156,7 +154,6 @@ typedef Stack CMStack; Clause *ForwardSubsumptionAndResolution::generateSubsumptionResolutionClause(Clause *cl, Literal *lit, Clause *baseClause) { - CALL("ForwardSubsumptionAndResolution::generateSubsumptionResolutionClause"); int clen = cl->length(); int nlen = clen - 1; @@ -215,8 +212,6 @@ bool checkForSubsumptionResolution(Clause *cl, ClauseMatches *cms, Literal *resL bool ForwardSubsumptionAndResolution::perform(Clause *cl, Clause *&replacement, ClauseIterator &premises) { - CALL("ForwardSubsumptionAndResolution::perform"); - Clause *resolutionClause = 0; unsigned clen = cl->length(); diff --git a/Inferences/ForwardSubsumptionDemodulation.cpp b/Inferences/ForwardSubsumptionDemodulation.cpp index 1762ef91d..d1b7330fe 100644 --- a/Inferences/ForwardSubsumptionDemodulation.cpp +++ b/Inferences/ForwardSubsumptionDemodulation.cpp @@ -44,7 +44,6 @@ using namespace Saturation; void ForwardSubsumptionDemodulation::attach(SaturationAlgorithm* salg) { - CALL("ForwardSubsumptionDemodulation::attach"); ForwardSimplificationEngine::attach(salg); _index.request(salg->getIndexManager(), FSD_SUBST_TREE); @@ -60,7 +59,6 @@ void ForwardSubsumptionDemodulation::attach(SaturationAlgorithm* salg) void ForwardSubsumptionDemodulation::detach() { - CALL("ForwardSubsumptionDemodulation::detach"); _index.release(); ForwardSimplificationEngine::detach(); } @@ -68,8 +66,6 @@ void ForwardSubsumptionDemodulation::detach() bool ForwardSubsumptionDemodulation::perform(Clause* cl, Clause*& replacement, ClauseIterator& premises) { - CALL("ForwardSubsumptionDemodulation::perform"); - // cl // vvvvvvvvvvvvvvvv // mcl matched /-- only look for a term to demodulate in this part! diff --git a/Inferences/FunctionEvaluation.cpp b/Inferences/FunctionEvaluation.cpp index c7b175adb..1f0e31a47 100644 --- a/Inferences/FunctionEvaluation.cpp +++ b/Inferences/FunctionEvaluation.cpp @@ -14,7 +14,6 @@ struct FunctionEvaluator; template Option trySimplifyUnaryMinus(PolyNf* evalArgs) { - CALL("trySimplifyUnaryMinus(PolyNf*)") using Numeral = typename Number::ConstantType; using Polynom = Polynom; diff --git a/Inferences/GaussianVariableElimination.cpp b/Inferences/GaussianVariableElimination.cpp index e75233835..63da878e9 100644 --- a/Inferences/GaussianVariableElimination.cpp +++ b/Inferences/GaussianVariableElimination.cpp @@ -25,7 +25,6 @@ using Balancer = Kernel::Rebalancing::BalancergveCnt++; Inference inf(SimplifyingInference1(Kernel::InferenceRule::GAUSSIAN_VARIABLE_ELIMINIATION, &cl)); diff --git a/Inferences/GlobalSubsumption.cpp b/Inferences/GlobalSubsumption.cpp index 37312f867..17726afbc 100644 --- a/Inferences/GlobalSubsumption.cpp +++ b/Inferences/GlobalSubsumption.cpp @@ -51,8 +51,6 @@ using namespace Saturation; void GlobalSubsumption::attach(SaturationAlgorithm* salg) { - CALL("GlobalSubsumption::attach"); - ASS(!_index); ForwardSimplificationEngine::attach(salg); @@ -68,8 +66,6 @@ void GlobalSubsumption::attach(SaturationAlgorithm* salg) void GlobalSubsumption::detach() { - CALL("GlobalSubsumption::detach"); - _index=0; _salg->getIndexManager()->release(GLOBAL_SUBSUMPTION_INDEX); ForwardSimplificationEngine::detach(); @@ -83,8 +79,6 @@ void GlobalSubsumption::detach() */ Clause* GlobalSubsumption::perform(Clause* cl, Stack& prems) { - CALL("GlobalSubsumption::perform/2"); - TIME_TRACE("global subsumption"); if(cl->color()==COLOR_LEFT) { @@ -274,8 +268,6 @@ struct GlobalSubsumption::Unit2ClFn bool GlobalSubsumption::perform(Clause* cl, Clause*& replacement, ClauseIterator& premises) { - CALL("GlobalSubsumption::perform/3"); - static Stack prems; Clause* newCl = perform(cl,prems); diff --git a/Inferences/GlobalSubsumption.hpp b/Inferences/GlobalSubsumption.hpp index 1dfdb64d2..e81129102 100644 --- a/Inferences/GlobalSubsumption.hpp +++ b/Inferences/GlobalSubsumption.hpp @@ -102,7 +102,6 @@ class GlobalSubsumption protected: unsigned splitLevelToVar(SplitLevel lev) { - CALL("GlobalSubsumption::splitLevelToVar"); unsigned* pvar; if(_splits2vars.getValuePtr(lev, pvar)) { @@ -115,8 +114,6 @@ class GlobalSubsumption } bool isSplitLevelVar(unsigned var, SplitLevel& lev) { - CALL("GlobalSubsumption::isSplitLevelVar"); - return _vars2splits.find(var,lev); } }; diff --git a/Inferences/Induction.cpp b/Inferences/Induction.cpp index 35d836e48..3f21d524d 100644 --- a/Inferences/Induction.cpp +++ b/Inferences/Induction.cpp @@ -45,7 +45,6 @@ using namespace Lib; Term* getPlaceholderForTerm(Term* t) { - CALL("getPlaceholderForTerm"); static DHMap placeholders; TermList srt = SortHelper::getResultSort(t); if(!placeholders.find(srt)){ @@ -60,8 +59,6 @@ Term* getPlaceholderForTerm(Term* t) TermList TermReplacement::transformSubterm(TermList trm) { - CALL("TermReplacement::transformSubterm"); - if(trm.isTerm() && trm.term()==_o){ return _r; } @@ -70,8 +67,6 @@ TermList TermReplacement::transformSubterm(TermList trm) TermList SkolemSquashingTermReplacement::transformSubterm(TermList trm) { - CALL("SkolemSquashingTermReplacement::transformSubterm"); - if(trm.isTerm()) { auto t = trm.term(); if (t==_o){ @@ -92,8 +87,6 @@ TermList SkolemSquashingTermReplacement::transformSubterm(TermList trm) Formula* InductionContext::getFormula(TermReplacement& tr, bool opposite) const { - CALL("InductionContext::getFormula/1"); - ASS(!_cls.empty()); auto argLists = FormulaList::empty(); for (const auto& kv : _cls) { @@ -109,8 +102,6 @@ Formula* InductionContext::getFormula(TermReplacement& tr, bool opposite) const Formula* InductionContext::getFormula(TermList r, bool opposite, Substitution* subst) const { - CALL("InductionContext::getFormula/2"); - TermReplacement tr(getPlaceholderForTerm(_indTerm), r); if (subst) { ASS(r.isVar()); @@ -122,8 +113,6 @@ Formula* InductionContext::getFormula(TermList r, bool opposite, Substitution* s Formula* InductionContext::getFormulaWithSquashedSkolems(TermList r, bool opposite, unsigned& var, VList** varList, Substitution* subst) const { - CALL("InductionContext::getFormulaWithSquashedSkolems"); - const bool strengthenHyp = env.options->inductionStrengthenHypothesis(); if (!strengthenHyp) { return getFormula(r, opposite, subst); @@ -158,7 +147,6 @@ ContextReplacement::ContextReplacement(const InductionContext& context) InductionContext ContextReplacement::next() { - CALL("ContextReplacement::next"); ASS(hasNext()); InductionContext context(_context._indTerm); for (const auto& kv : _context._cls) { @@ -175,7 +163,6 @@ InductionContext ContextReplacement::next() ContextReplacement* ContextSubsetReplacement::instance(const InductionContext& context, const Options& opt) { - CALL("ContextSubsetReplacement::instance"); if (opt.inductionGen()) { return new ContextSubsetReplacement(context, opt.maxInductionGenSubsetSize()); } @@ -195,7 +182,6 @@ ContextSubsetReplacement::ContextSubsetReplacement(const InductionContext& conte TermList ContextSubsetReplacement::transformSubterm(TermList trm) { - CALL("ContextSubsetReplacement::transformSubterm"); if (trm.isTerm() && trm.term() == _context._indTerm){ // Replace either if there are too many occurrences to try all possibilities, // or if the bit in _iteration corresponding to this match is set to 1. @@ -208,7 +194,6 @@ TermList ContextSubsetReplacement::transformSubterm(TermList trm) bool ContextSubsetReplacement::hasNext() { - CALL("ContextSubsetReplacement::hasNext"); if (_ready) { return hasNextInner(); } @@ -231,7 +216,6 @@ bool ContextSubsetReplacement::hasNext() } InductionContext ContextSubsetReplacement::next() { - CALL("ContextSubsetReplacement::next"); ASS(_ready); InductionContext context(_context._indTerm); _matchCount = 0; @@ -248,8 +232,6 @@ InductionContext ContextSubsetReplacement::next() { } void Induction::attach(SaturationAlgorithm* salg) { - CALL("Induction::attach"); - GeneratingInferenceEngine::attach(salg); if (InductionHelper::isIntInductionOneOn()) { _comparisonIndex = static_cast(_salg->getIndexManager()->request(UNIT_INT_COMPARISON_INDEX)); @@ -262,8 +244,6 @@ void Induction::attach(SaturationAlgorithm* salg) { } void Induction::detach() { - CALL("Induction::detach"); - if (InductionHelper::isNonUnitStructInductionOn()) { _structInductionTermIndex = nullptr; _salg->getIndexManager()->release(STRUCT_INDUCTION_TERM_INDEX); @@ -279,16 +259,12 @@ void Induction::detach() { ClauseIterator Induction::generateClauses(Clause* premise) { - CALL("Induction::generateClauses"); - return pvi(InductionClauseIterator(premise, InductionHelper(_comparisonIndex, _inductionTermIndex), getOptions(), _structInductionTermIndex, _formulaIndex)); } void InductionClauseIterator::processClause(Clause* premise) { - CALL("InductionClauseIterator::processClause"); - // The premise should either contain a literal on which we want to apply induction, // or it should be an integer constant comparison we use as a bound. if (InductionHelper::isInductionClause(premise)) { @@ -397,8 +373,6 @@ struct InductionContextFn void InductionClauseIterator::processLiteral(Clause* premise, Literal* lit) { - CALL("Induction::ClauseIterator::processLiteral"); - if(_opt.showInduction()){ env.beginOutput(); env.out() << "[Induction] process " << lit->toString() << " in " << premise->toString() << endl; @@ -555,8 +529,6 @@ void InductionClauseIterator::processLiteral(Clause* premise, Literal* lit) void InductionClauseIterator::processIntegerComparison(Clause* premise, Literal* lit) { - CALL("Induction::ClauseIterator::processIntegerComparison"); - ASS((theory->interpretPredicate(lit) == Theory::INT_LESS) && lit->ground()); bool positive = lit->isPositive(); @@ -614,7 +586,6 @@ void InductionClauseIterator::processIntegerComparison(Clause* premise, Literal* ClauseStack InductionClauseIterator::produceClauses(Formula* hypothesis, InferenceRule rule, const InductionContext& context) { - CALL("InductionClauseIterator::produceClauses"); NewCNF cnf(0); cnf.setForInduction(); Stack hyp_clauses; @@ -719,7 +690,6 @@ void InductionClauseIterator::resolveClauses(InductionContext context, Induction */ IntUnionFind findDistributedVariants(const Stack& clauses, Substitution& subst, const InductionContext& context) { - CALL("findDistributedVariants"); const auto& toResolve = context._cls; IntUnionFind uf(clauses.size()); for (unsigned i = 0; i < clauses.size(); i++) { @@ -797,7 +767,6 @@ IntUnionFind findDistributedVariants(const Stack& clauses, Substitution */ Clause* resolveClausesHelper(const InductionContext& context, const Stack& cls, IntUnionFind::ElementIterator eIt, Substitution& subst, bool generalized, bool applySubst) { - CALL("resolveClausesHelper"); // first create the clause with the required size ASS(eIt.hasNext()); auto cl = cls[eIt.next()]; @@ -878,7 +847,6 @@ Clause* resolveClausesHelper(const InductionContext& context, const StackrepresentConstant(IntegerConstantType(increasing ? 1 : -1))); @@ -1031,8 +995,6 @@ void InductionClauseIterator::performIntInduction(const InductionContext& contex void InductionClauseIterator::performStructInductionOne(const InductionContext& context, InductionFormulaIndex::Entry* e) { - CALL("InductionClauseIterator::performStructInductionOne"); - TermList sort = SortHelper::getResultSort(context._indTerm); TermAlgebra* ta = env.signature->getTermAlgebraOfSort(sort); unsigned numTypeArgs = sort.term()->arity(); @@ -1092,8 +1054,6 @@ void InductionClauseIterator::performStructInductionOne(const InductionContext& */ void InductionClauseIterator::performStructInductionTwo(const InductionContext& context, InductionFormulaIndex::Entry* e) { - CALL("InductionClauseIterator::performStructInductionTwo"); - TermList sort = SortHelper::getResultSort(context._indTerm); TermAlgebra* ta = env.signature->getTermAlgebraOfSort(sort); unsigned numTypeArgs = sort.term()->arity(); @@ -1178,8 +1138,6 @@ void InductionClauseIterator::performStructInductionTwo(const InductionContext& */ void InductionClauseIterator::performStructInductionThree(const InductionContext& context, InductionFormulaIndex::Entry* e) { - CALL("InductionClauseIterator::performStructInductionThree"); - TermList sort = SortHelper::getResultSort(context._indTerm); TermAlgebra* ta = env.signature->getTermAlgebraOfSort(sort); unsigned numTypeArgs = sort.term()->arity(); @@ -1289,7 +1247,6 @@ void InductionClauseIterator::performStructInductionThree(const InductionContext // are duplicates of normal formulas. bool InductionClauseIterator::notDoneInt(InductionContext context, Literal* bound1, Literal* bound2, InductionFormulaIndex::Entry*& e) { - CALL("InductionClauseIterator::notDoneInt"); TermList ph(getPlaceholderForTerm(context._indTerm)); Literal* b1 = nullptr; Literal* b2 = nullptr; diff --git a/Inferences/InductionHelper.cpp b/Inferences/InductionHelper.cpp index b75079653..aed15e3ac 100644 --- a/Inferences/InductionHelper.cpp +++ b/Inferences/InductionHelper.cpp @@ -44,8 +44,6 @@ struct SLQueryResultToTermQueryResultFn }; bool isIntegerComparisonLiteral(Literal* lit) { - CALL("isIntegerComparisonLiteral"); - if (!lit->ground() || !theory->isInterpretedPredicate(lit)) return false; switch (theory->interpretPredicate(lit)) { case Theory::INT_LESS: @@ -67,8 +65,6 @@ bool isIntegerComparisonLiteral(Literal* lit) { TermQueryResultIterator InductionHelper::getComparisonMatch( bool polarity, bool termIsLeft, Term* t) { - CALL("InductionHelper::getComparisonMatch"); - static unsigned less = env.signature->getInterpretingSymbol(Theory::INT_LESS); static TermList var(0, false); Literal* pattern = Literal::create2(less, polarity, termIsLeft ? TermList(t) : var, termIsLeft ? var : TermList(t)); @@ -78,7 +74,6 @@ TermQueryResultIterator InductionHelper::getComparisonMatch( TermQueryResultIterator InductionHelper::getLess(Term* t) { - CALL("InductionHelper::getLess"); return pvi(getConcatenatedIterator( // x <= t iff ~ t < x getComparisonMatch(/*polarity=*/false, /*termIsLeft=*/true, t), @@ -88,7 +83,6 @@ TermQueryResultIterator InductionHelper::getLess(Term* t) TermQueryResultIterator InductionHelper::getGreater(Term* t) { - CALL("InductionHelper::getGreater"); return pvi(getConcatenatedIterator( // x >= t iff ~ x < t getComparisonMatch(/*polarity=*/false, /*termIsLeft=*/false, t), @@ -97,63 +91,52 @@ TermQueryResultIterator InductionHelper::getGreater(Term* t) } TermQueryResultIterator InductionHelper::getTQRsForInductionTerm(Term* inductionTerm) { - CALL("InductionHelper::getIndTQRsForInductionTerm"); - ASS(_inductionTermIndex); return _inductionTermIndex->getUnifications(TypedTermList(inductionTerm)); } bool InductionHelper::isIntegerComparison(Clause* c) { - CALL("InductionHelper::isIntegerComparison"); if (c->length() != 1) return false; return isIntegerComparisonLiteral((*c)[0]); } bool InductionHelper::isIntInductionOn() { - CALL("InductionHelper::isIntInductionOn"); static bool intInd = env.options->induction() == Options::Induction::BOTH || env.options->induction() == Options::Induction::INTEGER; return intInd; } bool InductionHelper::isIntInductionOneOn() { - CALL("InductionHelper::isIntInductionOneOn"); return isIntInductionOn() && (env.options->intInduction() == Options::IntInductionKind::ONE); } bool InductionHelper::isIntInductionTwoOn() { - CALL("InductionHelper::isIntInductionTwoOn"); return isIntInductionOn() && (env.options->intInduction() == Options::IntInductionKind::TWO); } bool InductionHelper::isInductionForFiniteIntervalsOn() { - CALL("InductionHelper::isInductionForFiniteIntervalsOn"); static bool finite = env.options->integerInductionInterval() == Options::IntegerInductionInterval::FINITE || env.options->integerInductionInterval() == Options::IntegerInductionInterval::BOTH; return isIntInductionOn() && finite; } bool InductionHelper::isInductionForInfiniteIntervalsOn() { - CALL("InductionHelper::isInductionForInfiniteIntervalsOn"); static bool infinite = env.options->integerInductionInterval() == Options::IntegerInductionInterval::INFINITE || env.options->integerInductionInterval() == Options::IntegerInductionInterval::BOTH; return isIntInductionOn() && infinite; } bool InductionHelper::isStructInductionOn() { - CALL("InductionHelper::isStructInductionOn"); static bool structInd = env.options->induction() == Options::Induction::BOTH || env.options->induction() == Options::Induction::STRUCTURAL; return structInd; } bool InductionHelper::isNonUnitStructInductionOn() { - CALL("InductionHelper::isNonUnitStructInductionOn"); return isStructInductionOn() && env.options->nonUnitInduction(); } bool InductionHelper::isInductionClause(Clause* c) { - CALL("InductionHelper::isInductionClause"); static Options::InductionChoice kind = env.options->inductionChoice(); static bool all = (kind == Options::InductionChoice::ALL); static bool goal = (kind == Options::InductionChoice::GOAL); @@ -167,7 +150,6 @@ bool InductionHelper::isInductionClause(Clause* c) { } bool InductionHelper::isInductionLiteral(Literal* l) { - CALL("InductionHelper::isInductionLiteral"); static bool negOnly = env.options->inductionNegOnly(); return ((!negOnly || l->isNegative() || (theory->isInterpretedPredicate(l) && theory->isInequality(theory->interpretPredicate(l))) @@ -176,7 +158,6 @@ bool InductionHelper::isInductionLiteral(Literal* l) { } bool InductionHelper::isInductionTermFunctor(unsigned f) { - CALL("InductionHelper::isInductionTermFunctor"); static Options::InductionChoice kind = env.options->inductionChoice(); static bool all = (kind == Options::InductionChoice::ALL); static bool goal_plus = (kind == Options::InductionChoice::GOAL_PLUS); @@ -224,8 +205,6 @@ static bool termAndLiteralSatisfyStrictness(const TermList& tl, Literal* l, Opti } bool InductionHelper::isIntInductionTermListInLiteral(Term* tl, Literal* l) { - CALL("InductionHelper::isIntInductionTermInLiteral"); - // Term tl has to be an integer term. // Further, integer term tl from literal l cannot be used for induction if any // of the following conditions is satisfied. @@ -262,7 +241,6 @@ bool InductionHelper::isIntInductionTermListInLiteral(Term* tl, Literal* l) { } bool InductionHelper::isStructInductionTerm(Term* t) { - CALL("InductionHelper::isStructInductionFunctor"); static bool complexTermsAllowed = env.options->inductionOnComplexTerms(); return (env.signature->isTermAlgebraSort(SortHelper::getResultSort(t)) && // skip base constructors even if induction on complex terms is on: diff --git a/Inferences/InferenceEngine.cpp b/Inferences/InferenceEngine.cpp index 73fd408f1..8ee1460bf 100644 --- a/Inferences/InferenceEngine.cpp +++ b/Inferences/InferenceEngine.cpp @@ -51,7 +51,6 @@ typedef ApplicativeHelper AH; */ const Options& InferenceEngine::getOptions() const { - CALL("InferenceEngine::getOptions"); ASS(attached()); return _salg->getOptions(); @@ -267,8 +266,6 @@ CompositeSGI::~CompositeSGI() { Clause* ChoiceDefinitionISE::simplify(Clause* c) { - CALL("ChoiceDefinitionISE::simplify"); - if (c->length() != 2) { return c; } @@ -293,8 +290,6 @@ Clause* ChoiceDefinitionISE::simplify(Clause* c) } bool ChoiceDefinitionISE::isPositive(Literal* lit) { - CALL("ChoiceDefinitionISE::isPositive"); - TermList lhs = *lit->nthArgument(0); TermList rhs = *lit->nthArgument(1); if(!AH::isBool(lhs) && !AH::isBool(rhs)){ return false; } @@ -309,8 +304,6 @@ bool ChoiceDefinitionISE::isPositive(Literal* lit) { }; bool ChoiceDefinitionISE::is_of_form_xy(Literal* lit, TermList& x){ - CALL("ChoiceDefinitionISE::is_of_form_xy"); - TermList term = AH::isBool(*lit->nthArgument(0)) ? *lit->nthArgument(1) : *lit->nthArgument(0); TermStack args; @@ -319,8 +312,6 @@ bool ChoiceDefinitionISE::is_of_form_xy(Literal* lit, TermList& x){ } bool ChoiceDefinitionISE::is_of_form_xfx(Literal* lit, TermList x, TermList& f){ - CALL("ChoiceDefinitionISE::is_of_form_xfx"); - TermList term = AH::isBool(*lit->nthArgument(0)) ? *lit->nthArgument(1) : *lit->nthArgument(0); TermStack args; @@ -336,8 +327,6 @@ bool ChoiceDefinitionISE::is_of_form_xfx(Literal* lit, TermList x, TermList& f){ Clause* DuplicateLiteralRemovalISE::simplify(Clause* c) { - CALL("DuplicateLiteralRemovalISE::simplify"); - int length = c->length(); if (length <= 1) { return c; @@ -430,8 +419,6 @@ Clause* DuplicateLiteralRemovalISE::simplify(Clause* c) Clause* TautologyDeletionISE2::simplify(Clause* c) { - CALL("TautologyDeletionISE2::simplify"); - typedef ApplicativeHelper AH; static LiteralStack negLits; @@ -486,8 +473,6 @@ Clause* TautologyDeletionISE2::simplify(Clause* c) Clause* TrivialInequalitiesRemovalISE::simplify(Clause* c) { - CALL("TrivialInequalitiesRemovalISE::simplify"); - static DArray lits(32); typedef ApplicativeHelper AH; @@ -538,7 +523,6 @@ Clause* TrivialInequalitiesRemovalISE::simplify(Clause* c) Clause* SimplifyingGeneratingInference1::simplify(Clause* cl) { - CALL("SimplifyingGeneratingInference1::simplify(Clause*)") if (cl->isTheoryAxiom()) { DEBUG("skipping theory axiom") return cl; @@ -552,7 +536,6 @@ ImmediateSimplificationEngine& SimplifyingGeneratingInference1::asISE() SimplifyingGeneratingInference::ClauseGenerationResult SimplifyingGeneratingInference1::generateSimplify(Clause* cl) { - CALL("SimplifyingGeneratingInference1::generateClauses(Clause*)") auto gen = this->simplify(cl, true); auto simpl = gen.simplified; auto redundant = gen.premiseRedundant; @@ -574,8 +557,6 @@ SimplifyingGeneratingInference::ClauseGenerationResult SimplifyingGeneratingInfe } SimplifyingGeneratingInference1::Result SimplifyingGeneratingLiteralSimplification::simplify(Clause* cl_, bool doOrderingCheck) { - CALL("SimplifyingGeneratingLiteralSimplification::simplify"); - DEBUG("in: ", *cl_) auto& cl = *cl_; Stack out(cl.size()); diff --git a/Inferences/InferenceEngine.hpp b/Inferences/InferenceEngine.hpp index 216f6c252..a7bdf17e0 100644 --- a/Inferences/InferenceEngine.hpp +++ b/Inferences/InferenceEngine.hpp @@ -63,13 +63,11 @@ class InferenceEngine } virtual void attach(SaturationAlgorithm* salg) { - CALL("InferenceEngine::attach"); ASS(!_salg); _salg=salg; } virtual void detach() { - CALL("InferenceEngine::detach"); ASS(_salg); _salg=0; } diff --git a/Inferences/Injectivity.cpp b/Inferences/Injectivity.cpp index 4906a9e05..c2ce3e488 100644 --- a/Inferences/Injectivity.cpp +++ b/Inferences/Injectivity.cpp @@ -30,8 +30,6 @@ namespace Inferences { ClauseIterator Injectivity::generateClauses(Clause* premise) { - CALL("Injectivity::generateClauses"); - if(premise->length() != 2){ return ClauseIterator::getEmpty(); } @@ -110,8 +108,6 @@ ClauseIterator Injectivity::generateClauses(Clause* premise) { } TermList Injectivity::createNewLhs(TermList oldhead, TermStack& termArgs, unsigned index){ - CALL("Injectivity::createNewLhs"); - TermList* typeArg = oldhead.term()->args(); TermStack typeArgs; while(!typeArg->isEmpty()){ diff --git a/Inferences/InnerRewriting.cpp b/Inferences/InnerRewriting.cpp index 4a2817ae9..886429ca7 100644 --- a/Inferences/InnerRewriting.cpp +++ b/Inferences/InnerRewriting.cpp @@ -26,8 +26,6 @@ using namespace Kernel; bool InnerRewriting::perform(Clause* cl, Clause*& replacement, ClauseIterator& premises) { - CALL("InnerRewriting::perform"); - Ordering& ordering = _salg->getOrdering(); // look for the first equality which rewrites something and rewrite everything with it (check for EqTaut as you go) diff --git a/Inferences/Instantiation.cpp b/Inferences/Instantiation.cpp index 501baa2d2..a4ecebfe2 100644 --- a/Inferences/Instantiation.cpp +++ b/Inferences/Instantiation.cpp @@ -72,7 +72,6 @@ struct InvertNumber }; void Instantiation::init(){ - CALL("Instantiation::init"); Set* intSet = new Set(); Set* ratSet = new Set(); Set* realSet = new Set(); @@ -98,7 +97,6 @@ void Instantiation::init(){ */ void Instantiation::registerClause(Clause* cl) { - CALL("Instantiation::registerClause"); ASS(cl); //cout << "register " << cl->toString() << endl; @@ -141,8 +139,6 @@ void Instantiation::registerClause(Clause* cl) */ void Instantiation::tryMakeLiteralFalse(Literal* lit, Stack& subs) { - CALL("Instantiation::tryMakeLiteralFalse"); - if(theory->isInterpretedPredicate(lit->functor())){ Interpretation itp = theory->interpretPredicate(lit); //unsigned sort = theory->getOperationSort(interpretation); @@ -185,8 +181,6 @@ void Instantiation::tryMakeLiteralFalse(Literal* lit, Stack& subs) Term* Instantiation::tryGetDifferentValue(Term* t) { - CALL("Instantiation::tryGetDifferentValue"); - TermList sort = SortHelper::getResultSort(t); try { @@ -217,8 +211,6 @@ Term* Instantiation::tryGetDifferentValue(Term* t) VirtualIterator Instantiation::getCandidateTerms(Clause* cl, unsigned var,TermList sort) { - CALL("Instantiation::getCandidateTerms"); - Stack* cans=0; VirtualIterator res = VirtualIterator::getEmpty(); if(sorted_candidates.find(sort,cans) && cans->size()){ @@ -232,7 +224,6 @@ class Instantiation::AllSubstitutionsIterator{ DECL_ELEMENT_TYPE(Substitution); AllSubstitutionsIterator(Clause* cl,Instantiation* ins) { - CALL("Instantiation::AllSubstitutionsIterator"); DHMap sortedVars; SortHelper::collectVariableSorts(cl,sortedVars); VirtualIterator> it = sortedVars.items(); @@ -253,7 +244,6 @@ class Instantiation::AllSubstitutionsIterator{ Substitution next() { - CALL("AllSubstitutionsIterator::next") Substitution sub; VirtualIterator vs = candidates.domain(); while(vs.hasNext()){ @@ -292,8 +282,6 @@ struct Instantiation::ResultFn ResultFn(Clause* cl) : _cl(cl) {} Clause* operator()(Substitution sub) { - CALL("Instantiation::ResultFn::operator()"); - unsigned clen = _cl->length(); Clause* res = new(clen) Clause(clen,GeneratingInference1(InferenceRule::INSTANTIATION,_cl)); @@ -309,8 +297,6 @@ struct Instantiation::ResultFn ClauseIterator Instantiation::generateClauses(Clause* premise) { - CALL("Instantiation::generateClauses"); - //cout << "Instantiate " << premise->toString() << endl; Stack subs; @@ -333,4 +319,4 @@ ClauseIterator Instantiation::generateClauses(Clause* premise) } -} \ No newline at end of file +} diff --git a/Inferences/Instantiation.hpp b/Inferences/Instantiation.hpp index 762d9dcf7..97ffc15bb 100644 --- a/Inferences/Instantiation.hpp +++ b/Inferences/Instantiation.hpp @@ -59,4 +59,4 @@ class Instantiation }; -#endif /*__Instantiation__*/ \ No newline at end of file +#endif /*__Instantiation__*/ diff --git a/Inferences/InterpretedEvaluation.cpp b/Inferences/InterpretedEvaluation.cpp index 32527cd50..8f142ab99 100644 --- a/Inferences/InterpretedEvaluation.cpp +++ b/Inferences/InterpretedEvaluation.cpp @@ -43,13 +43,10 @@ using namespace Kernel; InterpretedEvaluation::InterpretedEvaluation(bool doNormalize, Ordering& ordering) : _simpl(new InterpretedLiteralEvaluator(doNormalize)) { - CALL("InterpretedEvaluation::InterpretedEvaluation"); } InterpretedEvaluation::~InterpretedEvaluation() { - CALL("InterpretedEvaluation::~InterpretedEvaluation"); - delete _simpl; } @@ -58,8 +55,6 @@ InterpretedEvaluation::~InterpretedEvaluation() bool InterpretedEvaluation::simplifyLiteral(Literal* lit, bool& constant, Literal*& res, bool& constantTrue,Stack& sideConditions) { - CALL("InterpretedEvaluation::evaluateLiteral"); - if(lit->numTermArguments()==0) { //we have no interpreted predicates of zero arity return false; @@ -76,7 +71,6 @@ bool InterpretedEvaluation::simplifyLiteral(Literal* lit, Clause* InterpretedEvaluation::simplify(Clause* cl) { - CALL("InterpretedEvaluation::perform"); try { diff --git a/Inferences/LfpRule.hpp b/Inferences/LfpRule.hpp index 03810886e..0f30f2a98 100644 --- a/Inferences/LfpRule.hpp +++ b/Inferences/LfpRule.hpp @@ -41,8 +41,6 @@ LfpRule::LfpRule() : _inner() {} template SimplifyingGeneratingInference1::Result LfpRule::simplify(Clause *cl, bool doCheckOrdering) { - CALL("LfpRule::simplify") - auto splits = cl->splits(); auto c0 = cl; // the parent of the current clause diff --git a/Inferences/Narrow.cpp b/Inferences/Narrow.cpp index 6d8e49294..167d26161 100644 --- a/Inferences/Narrow.cpp +++ b/Inferences/Narrow.cpp @@ -58,8 +58,6 @@ using namespace Saturation; void Narrow::attach(SaturationAlgorithm* salg) { - CALL("Narrow::attach"); - GeneratingInferenceEngine::attach(salg); _index=static_cast ( _salg->getIndexManager()->request(NARROWING_INDEX) ); @@ -67,8 +65,6 @@ void Narrow::attach(SaturationAlgorithm* salg) void Narrow::detach() { - CALL("Narrow::detach"); - _index=0; _salg->getIndexManager()->release(NARROWING_INDEX); GeneratingInferenceEngine::detach(); @@ -79,7 +75,6 @@ struct Narrow::ApplicableNarrowsFn ApplicableNarrowsFn(NarrowingIndex* index) : _index(index) {} VirtualIterator, TermQueryResult> > operator()(pair arg) { - CALL("Narrow::ApplicableRewritesFn()"); ASS(arg.second.isTerm()); TypedTermList tt(arg.second.term()); @@ -95,8 +90,6 @@ struct Narrow::RewriteableSubtermsFn VirtualIterator > operator()(Literal* lit) { - CALL("Narrow::RewriteableSubtermsFn()"); - return pvi( pushPairIntoRightIterator(lit, EqHelper::getNarrowableSubtermIterator(lit, _ord)) ); } @@ -111,8 +104,6 @@ struct Narrow::ResultFn ResultFn(Clause* cl, Narrow& parent) : _cl(cl), _parent(parent) {} Clause* operator()(pair, TermQueryResult> arg) { - CALL("Narrow::ResultFn::operator()"); - TermQueryResult& qr = arg.second; return _parent.performNarrow(_cl, arg.first.first, arg.first.second, qr.term, qr.literal, qr.substitution); @@ -124,8 +115,6 @@ struct Narrow::ResultFn ClauseIterator Narrow::generateClauses(Clause* premise) { - CALL("Narrow::generateClauses"); - //cout << "Narrow with " << premise->toString() << endl; auto it1 = premise->getSelectedLiteralIterator(); @@ -151,7 +140,6 @@ Clause* Narrow::performNarrow( Clause* nClause, Literal* nLiteral, TermList nTerm, TermList combAxLhs, Literal* combAx, ResultSubstitutionSP subst) { - CALL("Narrow::performNarrow"); // we want the rwClause and eqClause to be active ASS(nClause->store()==Clause::ACTIVE); ASS(nTerm.isTerm()); diff --git a/Inferences/NegativeExt.cpp b/Inferences/NegativeExt.cpp index 9049b870a..d9db015ca 100644 --- a/Inferences/NegativeExt.cpp +++ b/Inferences/NegativeExt.cpp @@ -61,8 +61,6 @@ struct NegativeExt::ResultFn Clause* operator() (Literal* lit) { - CALL("NegativeExt::ResultFn::operator()"); - ASS(lit->isEquality()); ASS(!lit->isPositive()); @@ -166,8 +164,6 @@ struct NegativeExt::ResultFn ClauseIterator NegativeExt::generateClauses(Clause* premise) { - CALL("NegativeExt::generateClauses"); - //cout << "NegativeExt with " + premise->toString() << endl; if(premise->isEmpty()) { return ClauseIterator::getEmpty(); diff --git a/Inferences/PolynomialEvaluation.cpp b/Inferences/PolynomialEvaluation.cpp index ac77bbf60..2a9cb64c3 100644 --- a/Inferences/PolynomialEvaluation.cpp +++ b/Inferences/PolynomialEvaluation.cpp @@ -29,8 +29,6 @@ PolynomialEvaluation::PolynomialEvaluation(Ordering& ordering) : SimplifyingGene Literal* createLiteral(Literal* orig, PolyNf* evaluatedArgs) { - CALL("createLiteral"); - if (orig->isEquality()) { return Literal::createEquality( orig->polarity(), @@ -53,7 +51,6 @@ Literal* createLiteral(Literal* orig, PolyNf* evaluatedArgs) { PolynomialEvaluation::Result PolynomialEvaluation::simplifyLiteral(Literal* lit) { - CALL("PolynomialEvaluation::simplifyLiteral"); TIME_TRACE("polynomial evaluation"); Stack terms(lit->numTermArguments()); @@ -78,7 +75,6 @@ PolynomialEvaluation::Result PolynomialEvaluation::simplifyLiteral(Literal* lit) #include "Kernel/PolynomialNormalizer/PredicateEvaluator.hpp" Option PolynomialEvaluation::tryEvalPredicate(Literal* orig, PolyNf* evaluatedArgs) const { - CALL("PolynomialEvaluation::tryEvalPredicate(Literal* term)") DEBUG("evaluating: ", orig->toString()); #define HANDLE_CASE(INTER) case Interpretation::INTER: return PredicateEvaluator::evaluate(orig, evaluatedArgs); @@ -128,7 +124,6 @@ Option PolynomialEvaluation::tryEvalPredicate(Literal* orig, Pol Option trySimplify(Theory::Interpretation i, PolyNf* evalArgs) { - CALL("trySimplify(Theory::Interpretation i, PolyNf* evalArgs) ") try { switch (i) { @@ -206,8 +201,6 @@ AnyPoly simplifyPoly(AnyPoly const& p, PolyNf* ts) Option PolynomialEvaluation::evaluate(PolyNf normalized) const { - CALL("PolynomialEvaluation::evaluate(TypedTermList term) const") - DEBUG("evaluating ", normalized) struct Eval { @@ -253,7 +246,6 @@ Option PolynomialEvaluation::evaluate(PolyNf normalized) const template Polynom simplifyPoly(Polynom const& in, PolyNf* simplifiedArgs) { - CALL("simplify(Polynomconst&, PolyNf* simplifiedArgs)") using Monom = Monom; using Polynom = Polynom; try { diff --git a/Inferences/PrimitiveInstantiation.cpp b/Inferences/PrimitiveInstantiation.cpp index 7d4457d11..0547467c8 100644 --- a/Inferences/PrimitiveInstantiation.cpp +++ b/Inferences/PrimitiveInstantiation.cpp @@ -44,8 +44,6 @@ using namespace Saturation; void PrimitiveInstantiation::attach(SaturationAlgorithm* salg) { - CALL("PrimitiveInstantiation::attach"); - GeneratingInferenceEngine::attach(salg); _index=static_cast ( _salg->getIndexManager()->request(PRIMITIVE_INSTANTIATION_INDEX) ); @@ -53,8 +51,6 @@ void PrimitiveInstantiation::attach(SaturationAlgorithm* salg) void PrimitiveInstantiation::detach() { - CALL("PrimitiveInstantiation::detach"); - _index=0; _salg->getIndexManager()->release(PRIMITIVE_INSTANTIATION_INDEX); GeneratingInferenceEngine::detach(); @@ -115,8 +111,6 @@ struct PrimitiveInstantiation::ApplicableRewritesFn ApplicableRewritesFn(PrimitiveInstantiationIndex* index) : _index(index){} VirtualIterator operator()(Literal* l) { - CALL("PrimitiveInstantiation::ApplicableRewritesFn()"); - TermList lhs = *l->nthArgument(0); TermList rhs = *l->nthArgument(1); @@ -136,8 +130,6 @@ struct PrimitiveInstantiation::ApplicableRewritesFn ClauseIterator PrimitiveInstantiation::generateClauses(Clause* premise) { - CALL("PrimitiveInstantiation::generateClauses"); - //is this correct? auto it1 = premise->getSelectedLiteralIterator(); //filter out literals that are not suitable for narrowing diff --git a/Inferences/PushUnaryMinus.cpp b/Inferences/PushUnaryMinus.cpp index 057cb5c3f..1d63978dd 100644 --- a/Inferences/PushUnaryMinus.cpp +++ b/Inferences/PushUnaryMinus.cpp @@ -36,7 +36,6 @@ ostream& operator<<(ostream& out, UMinus const& self) { TermList pushUMinus(UMinus outerMinus, TermList t) { - CALL("pushUMinus(UMinus outerMinus, TermList t) ") auto wrapMinus = [&](TermList t) { switch (outerMinus) { @@ -95,7 +94,6 @@ PushUnaryMinus::~PushUnaryMinus() {} Clause* PushUnaryMinus::simplify(Clause* cl_) { - CALL("PushUnaryMinus::simplify(Clause*)") DEBUG("in: ", *cl_) if (cl_->isTheoryAxiom()) return cl_; diff --git a/Inferences/RenamingOnTheFly.cpp b/Inferences/RenamingOnTheFly.cpp index edca725d2..4b583b853 100644 --- a/Inferences/RenamingOnTheFly.cpp +++ b/Inferences/RenamingOnTheFly.cpp @@ -39,8 +39,6 @@ typedef ApplicativeHelper AH; void RenamingOnTheFly::attach(SaturationAlgorithm* salg) { - CALL("RenamingOnTheFly::attach"); - SimplificationEngine::attach(salg); _formulaIndex=static_cast ( _salg->getIndexManager()->request(RENAMING_FORMULA_INDEX) ); @@ -48,8 +46,6 @@ void RenamingOnTheFly::attach(SaturationAlgorithm* salg) void RenamingOnTheFly::detach() { - CALL("RenamingOnTheFly::detach"); - _formulaIndex=0; _salg->getIndexManager()->release(RENAMING_FORMULA_INDEX); SimplificationEngine::detach(); @@ -57,8 +53,6 @@ void RenamingOnTheFly::detach() ClauseIterator RenamingOnTheFly::produceClauses(Clause* c) { - CALL("RenamingOnTheFly::produceClauses"); - //0 means dont rename static int namingBound = env.options->naming(); @@ -237,8 +231,6 @@ ClauseIterator RenamingOnTheFly::produceClauses(Clause* c) ClauseIterator RenamingOnTheFly::perform(Clause* c) { - CALL("RenamingOnTheFly::perform"); - if(c->inference()->rule() == Inference::PREDICATE_DEFINITION){ //dont want to name definitions return ClauseIterator::getEmpty(); @@ -251,8 +243,6 @@ ClauseIterator RenamingOnTheFly::perform(Clause* c) void RenamingOnTheFly::addToQueue(TermList formula, TermList name, Literal* lit, Clause* c) { - CALL("RenamingOnTheFly::addToQueue"); - _formulas.push(formula); _names.push(name); _lits.push(lit); @@ -261,8 +251,6 @@ void RenamingOnTheFly::addToQueue(TermList formula, TermList name, Literal* lit, void RenamingOnTheFly::processQueue() { - CALL("RenamingOnTheFly::processQueue"); - while(!_formulas.isEmpty()){ _formulaIndex->insertFormula(_formulas.pop(), _names.pop(), _lits.pop(), _clauses.pop()); } @@ -272,8 +260,6 @@ void RenamingOnTheFly::processQueue() bool RenamingOnTheFly::isNamingLit(Literal* lit) { - CALL("RenamingOnTheFly::isNamingLit"); - TermList lhs = *lit->nthArgument(0); TermList rhs = *lit->nthArgument(1); bool lhsIsAtom = AH::getProxy(AH::getHead(lhs)) == Signature::NOT_PROXY; @@ -283,8 +269,6 @@ bool RenamingOnTheFly::isNamingLit(Literal* lit) TermList RenamingOnTheFly::getFormula(Literal* lit) { - CALL("RenamingOnTheFly::getFormula"); - TermList lhs = *lit->nthArgument(0); TermList rhs = *lit->nthArgument(1); return AH::isBool(lhs) ? rhs : lhs; diff --git a/Inferences/SLQueryBackwardSubsumption.cpp b/Inferences/SLQueryBackwardSubsumption.cpp index 6218fd117..87cdfac36 100644 --- a/Inferences/SLQueryBackwardSubsumption.cpp +++ b/Inferences/SLQueryBackwardSubsumption.cpp @@ -53,7 +53,6 @@ using namespace Saturation; void SLQueryBackwardSubsumption::attach(SaturationAlgorithm* salg) { - CALL("SLQueryBackwardSubsumption::attach"); ASS(!_index); BackwardSimplificationEngine::attach(salg); @@ -63,7 +62,6 @@ void SLQueryBackwardSubsumption::attach(SaturationAlgorithm* salg) void SLQueryBackwardSubsumption::detach() { - CALL("SLQueryBackwardSubsumption::detach"); _index=0; _salg->getIndexManager()->release(BACKWARD_SUBSUMPTION_SUBST_TREE); BackwardSimplificationEngine::detach(); @@ -89,7 +87,6 @@ struct SLQueryBackwardSubsumption::ClauseToBwSimplRecordFn void SLQueryBackwardSubsumption::perform(Clause* cl, BwSimplificationRecordIterator& simplifications) { - CALL("SLQueryBackwardSubsumption::perform"); ASSERT_VALID(*cl); //we do all work in this method, so we can just measure time simply diff --git a/Inferences/SubVarSup.cpp b/Inferences/SubVarSup.cpp index 7a5f776c9..47a4afff1 100644 --- a/Inferences/SubVarSup.cpp +++ b/Inferences/SubVarSup.cpp @@ -58,8 +58,6 @@ using namespace Saturation; void SubVarSup::attach(SaturationAlgorithm* salg) { - CALL("SubVarSup::attach"); - GeneratingInferenceEngine::attach(salg); _subtermIndex=static_cast ( _salg->getIndexManager()->request(SUB_VAR_SUP_SUBTERM_SUBST_TREE) ); @@ -69,8 +67,6 @@ void SubVarSup::attach(SaturationAlgorithm* salg) void SubVarSup::detach() { - CALL("SubVarSup::detach"); - _subtermIndex=0; _lhsIndex=0; _salg->getIndexManager()->release(SUB_VAR_SUP_SUBTERM_SUBST_TREE); @@ -85,8 +81,6 @@ struct SubVarSup::RewritableResultsFn RewritableResultsFn(SubVarSupSubtermIndex* index) : _index(index) {} VirtualIterator, TermQueryResult> > operator()(pair arg) { - CALL("SubVarSup::RewritableResultsFn()"); - return pvi( pushPairIntoRightIterator(arg, _index->getUnifications(arg.second, /* retrieveSubstitutions */ true)) ); } private: @@ -101,7 +95,6 @@ struct SubVarSup::RewriteableSubtermsFn VirtualIterator > operator()(Literal* lit) { - CALL("SubVarSup::RewriteableSubtermsFn()"); return pvi( pushPairIntoRightIterator(lit, EqHelper::getRewritableVarsIterator(&_unstableVars, lit, _ord)) ); } @@ -115,8 +108,6 @@ struct SubVarSup::ApplicableRewritesFn ApplicableRewritesFn(SubVarSupLHSIndex* index) : _index(index) {} VirtualIterator, TermQueryResult> > operator()(pair arg) { - CALL("SubVarSup::ApplicableRewritesFn()"); - return pvi( pushPairIntoRightIterator(arg, _index->getUnifications(arg.second, /* retrieveSubst */ false)) ); } private: @@ -129,8 +120,6 @@ struct SubVarSup::ForwardResultFn ForwardResultFn(Clause* cl, SubVarSup& parent) : _cl(cl), _parent(parent) {} Clause* operator()(pair, TermQueryResult> arg) { - CALL("SubVarSup::ForwardResultFn::operator()"); - TermQueryResult& qr = arg.second; return _parent.performSubVarSup(_cl, arg.first.first, arg.first.second, qr.clause, qr.literal, qr.term, true); @@ -146,8 +135,6 @@ struct SubVarSup::BackwardResultFn BackwardResultFn(Clause* cl, SubVarSup& parent) : _cl(cl), _parent(parent) {} Clause* operator()(pair, TermQueryResult> arg) { - CALL("SubVarSup::BackwardResultFn::operator()"); - if(_cl==arg.second.clause) { return 0; } @@ -164,8 +151,6 @@ struct SubVarSup::BackwardResultFn ClauseIterator SubVarSup::generateClauses(Clause* premise) { - CALL("SubVarSup::generateClauses"); - //cout << "SubVarSup with " << premise->toString() << endl; auto itf1 = premise->getSelectedLiteralIterator(); @@ -210,7 +195,6 @@ Clause* SubVarSup::performSubVarSup( Clause* rwClause, Literal* rwLit, TermList rwTerm, Clause* eqClause, Literal* eqLit, TermList eqLHS, bool eqIsResult) { - CALL("SubVarSup::performSubVarSup"); // we want the rwClause and eqClause to be active ASS(rwClause->store()==Clause::ACTIVE); ASS(eqClause->store()==Clause::ACTIVE); diff --git a/Inferences/SubsumptionDemodulationHelper.cpp b/Inferences/SubsumptionDemodulationHelper.cpp index 02c76fcf2..89bd62fb1 100644 --- a/Inferences/SubsumptionDemodulationHelper.cpp +++ b/Inferences/SubsumptionDemodulationHelper.cpp @@ -138,8 +138,6 @@ bool SDHelper::checkForSubsumptionResolution(Clause* cl, SDClauseMatches const& */ Clause* SDHelper::generateSubsumptionResolutionClause(Clause* cl, Literal* resLit, Clause* mcl) { - CALL("generateSubsumptionResolutionClause"); - unsigned newLen = cl->length() - 1; Clause* newCl = new(newLen) Clause(newLen, SimplifyingInference2(InferenceRule::SUBSUMPTION_RESOLUTION, cl, mcl)); diff --git a/Inferences/SubsumptionDemodulationHelper.hpp b/Inferences/SubsumptionDemodulationHelper.hpp index efb30f005..ae0e9c9e7 100644 --- a/Inferences/SubsumptionDemodulationHelper.hpp +++ b/Inferences/SubsumptionDemodulationHelper.hpp @@ -344,8 +344,6 @@ class SDHelper template bool termContainsAllVariablesOfOtherUnderSubst(TermList term, TermList other, Applicator const& applicator) { - CALL("termContainsAllVariablesOfOtherUnderSubst"); - static vunordered_set vars(16); vars.clear(); diff --git a/Inferences/Superposition.cpp b/Inferences/Superposition.cpp index 809137b14..5c3452587 100644 --- a/Inferences/Superposition.cpp +++ b/Inferences/Superposition.cpp @@ -58,8 +58,6 @@ using namespace Saturation; void Superposition::attach(SaturationAlgorithm* salg) { - CALL("Superposition::attach"); - GeneratingInferenceEngine::attach(salg); _subtermIndex=static_cast ( _salg->getIndexManager()->request(SUPERPOSITION_SUBTERM_SUBST_TREE) ); @@ -69,8 +67,6 @@ void Superposition::attach(SaturationAlgorithm* salg) void Superposition::detach() { - CALL("Superposition::detach"); - _subtermIndex=0; _lhsIndex=0; _salg->getIndexManager()->release(SUPERPOSITION_SUBTERM_SUBST_TREE); @@ -83,8 +79,6 @@ struct Superposition::ForwardResultFn ForwardResultFn(Clause* cl, PassiveClauseContainer* passiveClauseContainer, Superposition& parent) : _cl(cl), _passiveClauseContainer(passiveClauseContainer), _parent(parent) {} Clause* operator()(pair, TermQueryResult> arg) { - CALL("Superposition::ForwardResultFn::operator()"); - TermQueryResult& qr = arg.second; return _parent.performSuperposition(_cl, arg.first.first, arg.first.second, qr.clause, qr.literal, qr.term, qr.substitution, true, _passiveClauseContainer, qr.constraints); @@ -101,8 +95,6 @@ struct Superposition::BackwardResultFn BackwardResultFn(Clause* cl, PassiveClauseContainer* passiveClauseContainer, Superposition& parent) : _cl(cl), _passiveClauseContainer(passiveClauseContainer), _parent(parent) {} Clause* operator()(pair, TermQueryResult> arg) { - CALL("Superposition::BackwardResultFn::operator()"); - if(_cl==arg.second.clause) { return 0; } @@ -120,7 +112,6 @@ struct Superposition::BackwardResultFn ClauseIterator Superposition::generateClauses(Clause* premise) { - CALL("Superposition::generateClauses"); PassiveClauseContainer* passiveClauseContainer = _salg->getPassiveClauseContainer(); //cout << "SUPERPOSITION with " << premise->toString() << endl; @@ -182,8 +173,6 @@ ClauseIterator Superposition::generateClauses(Clause* premise) */ bool Superposition::checkClauseColorCompatibility(Clause* eqClause, Clause* rwClause) { - CALL("Superposition::checkClauseColorCompatibility"); - if(ColorHelper::compatible(rwClause->color(), eqClause->color())) { return true; } @@ -214,7 +203,6 @@ bool Superposition::checkClauseColorCompatibility(Clause* eqClause, Clause* rwCl */ bool Superposition::checkSuperpositionFromVariable(Clause* eqClause, Literal* eqLit, TermList eqLHS) { - CALL("Superposition::checkSuperpositionFromVariable"); ASS(eqLHS.isVar()); //if we should do rewriting, LHS cannot appear inside RHS //ASS_REP(!EqHelper::getOtherEqualitySide(eqLit, eqLHS).containsSubterm(eqLHS), eqLit->toString()); @@ -254,8 +242,6 @@ bool Superposition::earlyWeightLimitCheck(Clause* eqClause, Literal* eqLit, Clause* rwClause, Literal* rwLit, TermList rwTerm, TermList eqLHS, TermList eqRHS, ResultSubstitutionSP subst, bool eqIsResult, PassiveClauseContainer* passiveClauseContainer, unsigned numPositiveLiteralsLowerBound, const Inference& inf) { - CALL("Superposition::earlyWeightLimitCheck"); - unsigned nonInvolvedLiteralWLB=0;//weight lower bound for literals that aren't going to be rewritten unsigned rwLength = rwClause->length(); @@ -327,7 +313,6 @@ Clause* Superposition::performSuperposition( ResultSubstitutionSP subst, bool eqIsResult, PassiveClauseContainer* passiveClauseContainer, UnificationConstraintStackSP constraints) { - CALL("Superposition::performSuperposition"); TIME_TRACE("perform superposition"); // we want the rwClause and eqClause to be active ASS(rwClause->store()==Clause::ACTIVE); diff --git a/Inferences/TautologyDeletionISE.cpp b/Inferences/TautologyDeletionISE.cpp index a0eb8afc2..4783a9846 100644 --- a/Inferences/TautologyDeletionISE.cpp +++ b/Inferences/TautologyDeletionISE.cpp @@ -28,8 +28,6 @@ using namespace Inferences; Clause* TautologyDeletionISE::simplify(Clause* c) { - CALL("TautologyDeletionISE::simplify"); - static DArray plits(32); // array of positive literals static DArray nlits(32); // array of negative literals @@ -95,8 +93,6 @@ Clause* TautologyDeletionISE::simplify(Clause* c) */ int TautologyDeletionISE::compare(Literal* l1,Literal* l2) { - CALL("TautologyDeletionISE::compare"); - unsigned f1 = l1->functor(); unsigned f2 = l2->functor(); if (f1 < f2) { @@ -148,7 +144,6 @@ int TautologyDeletionISE::compare(Literal* l1,Literal* l2) */ void TautologyDeletionISE::sort(Literal** lits,int to) { - CALL("TautologyDeletionISE::sort"); ASS(to > 1); // array behaves as a stack of calls to quicksort diff --git a/Inferences/TermAlgebraReasoning.cpp b/Inferences/TermAlgebraReasoning.cpp index f73aad865..f68bab975 100644 --- a/Inferences/TermAlgebraReasoning.cpp +++ b/Inferences/TermAlgebraReasoning.cpp @@ -39,8 +39,6 @@ namespace Inferences { // copy clause c, replacing literal a by b Clause* replaceLit(Clause *c, Literal *a, Literal *b, const Inference& inf) { - CALL("replaceLit"); - int length = c->length(); Clause* res = new(length) Clause(length,inf); @@ -55,8 +53,6 @@ namespace Inferences { // copy clause c, with the exception of the i-th literal Clause* removeLit(Clause *c, unsigned i, const Inference& inf) { - CALL("removeLit"); - unsigned length = c->length(); ASS_GE(i, 0); ASS_L(i, length); @@ -73,8 +69,6 @@ namespace Inferences { // algebra constructor, or nullptr otherwise Signature::Symbol* termAlgebraConstructor(TermList *t) { - CALL("termAlgebraConstructor"); - if (t->isTerm()) { Signature::Symbol *s = env.signature->getFunction(t->term()->functor()); @@ -90,8 +84,6 @@ namespace Inferences { // equality of disequality bool distinctConstructorsEquality(Literal *lit) { - CALL("distinctConstructorsEquality"); - if (!lit->isEquality()) return false; @@ -105,8 +97,6 @@ namespace Inferences { // where f is a term algebra constructor bool sameConstructorsEquality(Literal *lit) { - CALL("sameConstructorsEquality"); - if (!lit->isEquality()) return false; @@ -118,8 +108,6 @@ namespace Inferences { Clause* DistinctnessISE::simplify(Clause* c) { - CALL("DistinctnessISE::simplify"); - if (c->isPureTheoryDescendant()) return c; @@ -169,8 +157,6 @@ namespace Inferences { bool hasNext() { return _index < _length; } OWN_ELEMENT_TYPE next() { - CALL("InjectivityGIE::SubtermIterator::next()"); - // from the clause f(x1 ... xn) = f(y1 .. yn) \/ C, we create // a new clause xi = yi \/ C. In this case, next() can be // called n times to create the n relevant conclusions. @@ -201,8 +187,6 @@ namespace Inferences { : _premise(premise) {} VirtualIterator operator()(Literal* lit) { - CALL("InjectivityGIE::SubtermEqualityFn::operator()"); - return pvi(SubtermIterator(_premise, lit)); } private: @@ -211,8 +195,6 @@ namespace Inferences { ClauseIterator InjectivityGIE::generateClauses(Clause* c) { - CALL("InjectivityGIE::generateClauses"); - auto it1 = c->getSelectedLiteralIterator(); auto it2 = getMappingIterator(it1, SubtermEqualityFn(c)); auto it3 = getFlattenedIterator(it2); @@ -221,8 +203,6 @@ namespace Inferences { Clause* InjectivityISE::simplify(Clause *c) { - CALL("InjectivityISE::simplify"); - if (c->isPureTheoryDescendant()) return c; @@ -248,7 +228,6 @@ namespace Inferences { bool NegativeInjectivityISE::litCondition(Clause *c, unsigned i) { - CALL("NegativeInjectivityISE::litCondition"); Literal *lit = (*c)[i]; if (sameConstructorsEquality(lit) && !lit->polarity()) { unsigned numTypeArguments = lit->nthArgument(0)->term()->numTypeArguments(); @@ -273,8 +252,6 @@ namespace Inferences { Clause* NegativeInjectivityISE::simplify(Clause *c) { - CALL("NegativeInjectivityISE::simplify"); - if (c->isPureTheoryDescendant()) return c; @@ -316,8 +293,6 @@ namespace Inferences { void AcyclicityGIE::attach(SaturationAlgorithm* salg) { - CALL("AcyclicityGIE::attach"); - GeneratingInferenceEngine::attach(salg); _acyclIndex = static_cast(_salg->getIndexManager()->request(ACYCLICITY_INDEX)); @@ -325,8 +300,6 @@ namespace Inferences { void AcyclicityGIE::detach() { - CALL("AcyclicityGIE::detach"); - _acyclIndex = 0; _salg->getIndexManager()->release(ACYCLICITY_INDEX); GeneratingInferenceEngine::detach(); @@ -346,8 +319,6 @@ namespace Inferences { OWN_ELEMENT_TYPE next() { - CALL("AcyclicityGIE::AcyclicityGenIterator::next()"); - Indexing::CycleQueryResult *qres = _queryResults.next(); ASS_EQ(LiteralList::length(qres->literals), ClauseList::length(qres->premises)); @@ -404,8 +375,6 @@ namespace Inferences { {} VirtualIterator operator()(Literal* lit) { - CALL("AcyclicityGIE::AyclicityGenFn::operator()"); - return pvi(AcyclicityGenIterator(_premise, _aidx->queryCycles(lit, _premise))); } private: @@ -415,8 +384,6 @@ namespace Inferences { ClauseIterator AcyclicityGIE::generateClauses(Clause *c) { - CALL("AcyclicityGIE::generateClauses"); - auto it1 = c->getSelectedLiteralIterator(); auto it2 = getMappingIterator(it1, AcyclicityGenFn(_acyclIndex, c)); auto it3 = getFlattenedIterator(it2); @@ -425,8 +392,6 @@ namespace Inferences { void pushSubterms(TermList *tl, Stack &stack) { - CALL("getSubterms"); - if (!termAlgebraConstructor(tl)) { return; } @@ -499,8 +464,6 @@ namespace Inferences { OWN_ELEMENT_TYPE next() { - CALL("InjectivityGIE::SubtermIterator::next()"); - Literal *newlit = Literal::createEquality(false, *_lit->nthArgument(_leftSide ? 0 : 1), *_subterms.pop(), @@ -524,8 +487,6 @@ namespace Inferences { : _premise(premise) {} VirtualIterator operator()(Literal* lit) { - CALL("AcyclicityGIE1::SubtermDisequalityFn::operator()"); - return pvi(SubtermDisequalityIterator(_premise, lit)); } private: @@ -556,8 +517,6 @@ namespace Inferences { ClauseIterator AcyclicityGIE1::generateClauses(Clause* c) { - CALL("AcyclicityGIE1::generateClauses"); - LiteralIterator it1(c); auto it2 = getMappingIterator(it1, SubtermDisequalityFn(c)); auto it3 = getFlattenedIterator(it2); diff --git a/Inferences/TheoryInstAndSimp.cpp b/Inferences/TheoryInstAndSimp.cpp index 995a6e911..cdae34a03 100644 --- a/Inferences/TheoryInstAndSimp.cpp +++ b/Inferences/TheoryInstAndSimp.cpp @@ -104,8 +104,6 @@ TheoryInstAndSimp::TheoryInstAndSimp(Options::TheoryInstSimp mode, bool thiTauto void TheoryInstAndSimp::attach(SaturationAlgorithm* salg) { - CALL("Superposition::attach"); - SimplifyingGeneratingInference::attach(salg); _splitter = salg->getSplitter(); } @@ -114,7 +112,6 @@ void TheoryInstAndSimp::attach(SaturationAlgorithm* salg) bool TheoryInstAndSimp::calcIsSupportedSort(SortId sort) { - CALL("TheoryInstAndSimp::calcIsSupportedSort") //TODO: extend for more sorts (arrays, datatypes) if( sort == IntTraits::sort() || sort == RatTraits::sort() @@ -300,7 +297,6 @@ bool TheoryInstAndSimp::literalContainsVar(const Literal* lit, unsigned v) { **/ Stack TheoryInstAndSimp::selectTrivialLiterals(Clause* cl) { - CALL("TheoryInstAndSimp::selectTrivialLiterals"); #if DPRINT cout << "selecting trivial literals in " << cl->toString() << endl ; #endif @@ -404,7 +400,6 @@ Stack TheoryInstAndSimp::selectTrivialLiterals(Clause* cl) * Selects the theory literals to be used for instantiation. These are all non-trivial pure theory literals. */ Stack TheoryInstAndSimp::selectTheoryLiterals(Clause* cl) { - CALL("TheoryInstAndSimp::selectTheoryLiterals"); #if DPRINT cout << "selectTheoryLiterals in " << cl->toString() << endl; #endif @@ -535,8 +530,6 @@ class TheoryInstAndSimp::GeneralisationTree { Option TheoryInstAndSimp::instantiateGeneralised( SkolemizedLiterals skolem, unsigned freshVar) { - CALL("TheoryInstAndSimp::instantiateGeneralised(..)") - auto negatedClause = [](Stack lits) -> SATClause* { for (auto& lit : lits) { @@ -595,8 +588,6 @@ Option TheoryInstAndSimp::instantiateGeneralised( Option TheoryInstAndSimp::instantiateWithModel(SkolemizedLiterals skolem) { - CALL("TheoryInstAndSimp::instantiateWithModel(..)") - for (auto var : skolem.vars) { auto ev = _solver->evaluateInModel(skolem.subst.apply(var).term()); if (ev) { @@ -657,8 +648,6 @@ template TheoryInstAndSimp::SkolemizedLiterals TheoryInstAndSimp VirtualIterator TheoryInstAndSimp::getSolutions(Stack const& theoryLiterals, Stack const& guards, unsigned freshVar) { - CALL("TheoryInstAndSimp::getSolutions"); - BYPASSING_ALLOCATOR; auto skolemized = skolemize(iterTraits(getConcatenatedIterator( @@ -734,8 +723,6 @@ struct InstanceFn bool& redundant ) { - CALL("TheoryInstAndSimp::InstanceFn::operator()"); - // We delete cl as it's a theory-tautology if(!sol.sat) { // now we run SMT solver again without guarding @@ -768,8 +755,6 @@ struct InstanceFn Stack computeGuards(Stack const& lits) { - CALL("computeGuards"); - /* finds the constructor for a given distructor */ auto findConstructor = [](TermAlgebra* ta, unsigned destructor, bool predicate) -> TermAlgebraConstructor* { @@ -929,8 +914,6 @@ static const char* THEORY_INST_SIMP = "theory instantiation and simplification"; SimplifyingGeneratingInference::ClauseGenerationResult TheoryInstAndSimp::generateSimplify(Clause* premise) { - CALL("TheoryInstAndSimp::generateSimplify"); - auto empty = ClauseGenerationResult { .clauses = ClauseIterator::getEmpty(), .premiseRedundant = false, @@ -999,7 +982,6 @@ std::ostream& operator<<(std::ostream& out, Solution const& self) TheoryInstAndSimp::~TheoryInstAndSimp() { - CALL("~TheoryInstAndSimp") BYPASSING_ALLOCATOR delete _solver; } diff --git a/Inferences/URResolution.cpp b/Inferences/URResolution.cpp index df685e612..7b461af94 100644 --- a/Inferences/URResolution.cpp +++ b/Inferences/URResolution.cpp @@ -62,7 +62,6 @@ URResolution::URResolution(bool selectedOnly, UnitClauseLiteralIndex* unitIndex, void URResolution::attach(SaturationAlgorithm* salg) { - CALL("URResolution::attach"); ASS(!_unitIndex); ASS(!_nonUnitIndex); @@ -80,8 +79,6 @@ void URResolution::attach(SaturationAlgorithm* salg) void URResolution::detach() { - CALL("URResolution::detach"); - _unitIndex = 0; _salg->getIndexManager()->release(URR_UNIT_CLAUSE_SUBST_TREE); _nonUnitIndex = 0; @@ -98,8 +95,6 @@ struct URResolution::Item : _mustResolveAll(mustResolveAll || (selectedOnly ? true : (cl->length() < 2)) ), _orig(cl), _color(cl->color()), _parent(parent) { - CALL("URResolution::Item::Item"); - unsigned clen = cl->length(); _premises.init(clen, 0); _lits.ensure(clen); @@ -126,8 +121,6 @@ struct URResolution::Item */ void resolveLiteral(unsigned idx, SLQueryResult& unif, Clause* premise, bool useQuerySubstitution) { - CALL("URResolution::Item::resolveLiteral"); - _lits[idx] = 0; _premises[idx] = premise; _color = static_cast(_color | premise->color()); @@ -154,8 +147,6 @@ struct URResolution::Item Clause* generateClause() const { - CALL("URResolution::Item::generateClause"); - UnitList* premLst = 0; UnitList::push(_orig, premLst); Literal* single = 0; @@ -188,8 +179,6 @@ struct URResolution::Item int getGoodness(Literal* lit) { - CALL("URResolution::Item::getGoodness"); - return lit->weight() - lit->getDistinctVars(); } @@ -201,8 +190,6 @@ struct URResolution::Item */ void getBestLiteralReady(unsigned idx) { - CALL("URResolution::Item::getBestLiteralReady"); - ASS_L(idx, _activeLength); unsigned choiceSize = _activeLength - idx; @@ -259,8 +246,6 @@ struct URResolution::Item */ void URResolution::processLiteral(ItemList*& itms, unsigned idx) { - CALL("URResolution::processLiteral"); - ItemList::DelIterator iit(itms); while(iit.hasNext()) { Item* itm = iit.next(); @@ -311,8 +296,6 @@ void URResolution::processLiteral(ItemList*& itms, unsigned idx) */ void URResolution::processAndGetClauses(Item* itm, unsigned startIdx, ClauseList*& acc) { - CALL("URResolution::processAndGetClauses"); - unsigned activeLen = itm->_activeLength; ItemList* itms = 0; @@ -335,7 +318,6 @@ void URResolution::processAndGetClauses(Item* itm, unsigned startIdx, ClauseList */ void URResolution::doBackwardInferences(Clause* cl, ClauseList*& acc) { - CALL("URResolution::doBackwardInferences"); ASS_EQ(cl->size(), 1); Literal* lit = (*cl)[0]; @@ -361,8 +343,6 @@ void URResolution::doBackwardInferences(Clause* cl, ClauseList*& acc) ClauseIterator URResolution::generateClauses(Clause* cl) { - CALL("URResolution::generateClauses"); - unsigned clen = cl->size(); if(clen<1) { return ClauseIterator::getEmpty(); diff --git a/InstGen/IGAlgorithm.cpp b/InstGen/IGAlgorithm.cpp index 0ef611051..ee0a66841 100644 --- a/InstGen/IGAlgorithm.cpp +++ b/InstGen/IGAlgorithm.cpp @@ -66,8 +66,6 @@ IGAlgorithm::IGAlgorithm(Problem& prb,const Options& opt) _tautologyDeletion(false), _equalityProxy(0) { - CALL("IGAlgorithm::IGAlgorithm"); - _ordering = OrderingSP(Ordering::create(prb, opt)); if (opt.instGenSelection() == LOOKAHEAD_SELECTION) { @@ -118,8 +116,6 @@ IGAlgorithm::IGAlgorithm(Problem& prb,const Options& opt) IGAlgorithm::~IGAlgorithm() { - CALL("IGAlgorithm::~IGAlgorithm"); - delete _selected; delete _variantIdx; delete _satSolver; @@ -130,8 +126,6 @@ IGAlgorithm::~IGAlgorithm() ClauseIterator IGAlgorithm::getActive() { - CALL("IGAlgorithm::getActive"); - return pvi( RCClauseStack::Iterator(_active) ); } @@ -147,8 +141,6 @@ ClauseIterator IGAlgorithm::getActive() */ void IGAlgorithm::init() { - CALL("IGAlgorithm::init"); - if(_opt.instGenWithResolution()) { _saturationIndexManager = new IndexManager(0); if(_opt.globalSubsumption()) { @@ -200,8 +192,6 @@ void IGAlgorithm::init() bool IGAlgorithm::addClause(Clause* cl) { - CALL("IGAlgorithm::addClause"); - TIME_TRACE("inst gen simplifications"); cl = _duplicateLiteralRemoval.simplify(cl); @@ -264,7 +254,6 @@ bool IGAlgorithm::addClause(Clause* cl) Clause* IGAlgorithm::getFORefutation(SATClause* satRefutation, SATClauseList* satPremises) { - CALL("IGAlgorithm::getFORefutation"); ASS(satRefutation); UnitList* prems = SATInference::getFOPremises(satRefutation); @@ -279,8 +268,6 @@ Clause* IGAlgorithm::getFORefutation(SATClause* satRefutation, SATClauseList* sa void IGAlgorithm::processUnprocessed() { - CALL("IGAlgorithm::processUnprocessed"); - TIME_TRACE("inst gen SAT solving"); if (env.options->randomTraversals()) { @@ -318,8 +305,6 @@ void IGAlgorithm::processUnprocessed() bool IGAlgorithm::isSelected(Literal* lit) { - CALL("IGAlgorithm::isSelected"); - return _satSolver->trueInAssignment(_gnd->groundLiteral(lit)); } @@ -336,8 +321,6 @@ bool IGAlgorithm::isSelected(Literal* lit) */ bool IGAlgorithm::startGeneratingClause(Clause* orig, ResultSubstitution& subst, bool isQuery, Clause* otherCl,Literal* origLit, LiteralStack& genLits, bool& properInstance) { - CALL("IGAlgorithm::startGeneratingClause"); - #if VTRACE_DM cout << "tryGenC " << orig->number() << " and " << otherCl->number() << " on " << origLit->toString() << endl; #endif @@ -394,8 +377,6 @@ bool IGAlgorithm::startGeneratingClause(Clause* orig, ResultSubstitution& subst, */ void IGAlgorithm::finishGeneratingClause(Clause* orig, ResultSubstitution& subst, bool isQuery, Clause* otherCl,Literal* origLit, LiteralStack& genLits) { - CALL("IGAlgorithm::finishGeneratingClause"); - Clause* res = Clause::fromStack(genLits, GeneratingInference1(InferenceRule::INSTANCE_GENERATION, orig)); // make age also depend on the age of otherCl res->setAge(max(orig->age(), otherCl->age())+1); @@ -436,8 +417,6 @@ void IGAlgorithm::finishGeneratingClause(Clause* orig, ResultSubstitution& subst */ void IGAlgorithm::tryGeneratingInstances(Clause* cl, unsigned litIdx) { - CALL("IGAlgorithm::tryGeneratingInstances"); - TIME_TRACE("inst gen generating instances"); Literal* lit = (*cl)[litIdx]; @@ -486,8 +465,6 @@ void IGAlgorithm::tryGeneratingInstances(Clause* cl, unsigned litIdx) // */ //void IGAlgorithm::collectSelected(LiteralSubstitutionTree& acc) //{ -// CALL("IGAlgorithm::collectSelected"); -// // RCClauseStack::Iterator cit(_active); // while(cit.hasNext()) { // Clause* cl = cit.next(); @@ -508,8 +485,6 @@ void IGAlgorithm::tryGeneratingInstances(Clause* cl, unsigned litIdx) */ unsigned IGAlgorithm::lookaheadSelection(Clause* cl, unsigned selCnt) { - CALL("IGAlgorithm::lookaheadSelection"); - static DArray> iters; //IG unification iterators iters.ensure(selCnt); @@ -558,8 +533,6 @@ unsigned IGAlgorithm::lookaheadSelection(Clause* cl, unsigned selCnt) */ void IGAlgorithm::selectAndAddToIndex(Clause* cl) { - CALL("IGAlgorithm::selectAndAddToIndex"); - bool modified = false; unsigned selIdx = 0; @@ -596,8 +569,6 @@ void IGAlgorithm::selectAndAddToIndex(Clause* cl) void IGAlgorithm::removeFromIndex(Clause* cl) { - CALL("IGAlgorithm::removeFromIndex"); - unsigned selCnt = cl->numSelected(); for(unsigned i=0; iremove((*cl)[i], cl); @@ -606,8 +577,6 @@ void IGAlgorithm::removeFromIndex(Clause* cl) void IGAlgorithm::onResolutionClauseDerived(Clause* cl) { - CALL("IGAlgorithm::onResolutionClauseDerived"); - if(!cl->noSplits()) { return; } @@ -632,8 +601,6 @@ void IGAlgorithm::onResolutionClauseDerived(Clause* cl) void IGAlgorithm::doResolutionStep() { - CALL("IGAlgorithm::doResolutionStep"); - if(!_saturationAlgorithm) { return; } @@ -665,8 +632,6 @@ void IGAlgorithm::doResolutionStep() void IGAlgorithm::activate(Clause* cl, bool wasDeactivated) { - CALL("IGAlgorithm::activate"); - selectAndAddToIndex(cl); if (env.options->showActive()) { @@ -691,8 +656,6 @@ void IGAlgorithm::activate(Clause* cl, bool wasDeactivated) void IGAlgorithm::deactivate(Clause* cl) { - CALL("IGAlgorithm::deactivate"); - if(_deactivatedSet.insert(cl)) { _deactivated.push(cl); } @@ -700,8 +663,6 @@ void IGAlgorithm::deactivate(Clause* cl) void IGAlgorithm::doImmediateReactivation() { - CALL("IGAlgorithm::doImmediateReactivation"); - static ClauseStack toActivate; toActivate.reset(); @@ -723,8 +684,6 @@ void IGAlgorithm::doImmediateReactivation() void IGAlgorithm::doPassiveReactivation() { - CALL("IGAlgorithm::doPassiveReactivation"); - static ClauseStack toActivate; toActivate.reset(); @@ -746,8 +705,6 @@ void IGAlgorithm::doPassiveReactivation() void IGAlgorithm::wipeIndexes() { - CALL("IGAlgorithm::wipeIndexes"); - _deactivated.reset(); _deactivatedSet.reset(); @@ -764,8 +721,6 @@ void IGAlgorithm::wipeIndexes() void IGAlgorithm::restartWithCurrentClauses() { - CALL("IGAlgorithm::restartWithCurrentClauses"); - static RCClauseStack allClauses; allClauses.reset(); @@ -790,8 +745,6 @@ void IGAlgorithm::restartWithCurrentClauses() void IGAlgorithm::restartFromBeginning() { - CALL("IGAlgorithm::restartFromBeginning"); - /* { // throw away dismatching constraints @@ -820,8 +773,6 @@ void IGAlgorithm::restartFromBeginning() MainLoopResult IGAlgorithm::runImpl() { - CALL("IGAlgorithm::runImpl"); - RCClauseStack::Iterator icit(_inputClauses); while(icit.hasNext()) { Clause* cl = icit.next(); @@ -910,8 +861,6 @@ MainLoopResult IGAlgorithm::runImpl() MainLoopResult IGAlgorithm::onModelFound() { - CALL("IGAlgorithm::onModelFound"); - if(_opt.complete(_prb)) { MainLoopResult res(Statistics::SATISFIABLE); if(_opt.proof()!=Options::Proof::OFF) { diff --git a/InstGen/ModelPrinter.cpp b/InstGen/ModelPrinter.cpp index 178d69df8..c03437dd9 100644 --- a/InstGen/ModelPrinter.cpp +++ b/InstGen/ModelPrinter.cpp @@ -34,13 +34,10 @@ using namespace Shell; ModelPrinter::ModelPrinter(IGAlgorithm& iga) : _iga(iga) { - CALL("ModelPrinter::ModelPrinter"); } bool ModelPrinter::haveNonDefaultSorts() { - CALL("ModelPrinter::haveNonDefaultSorts"); - unsigned funs = env.signature->functions(); for(unsigned i=0; igetFunction(i)->fnType(); @@ -56,8 +53,6 @@ bool ModelPrinter::haveNonDefaultSorts() bool ModelPrinter::isEprProblem() { - CALL("ModelPrinter::isEprProblem"); - unsigned funCnt = env.signature->functions(); for(unsigned i=0; ifunctionArity(i)>0) { @@ -69,8 +64,6 @@ bool ModelPrinter::isEprProblem() bool ModelPrinter::tryOutput(ostream& stm) { - CALL("ModelPrinter::tryOutput"); - if(!isEprProblem() || !haveNonDefaultSorts()) { return false; } @@ -113,8 +106,6 @@ bool ModelPrinter::tryOutput(ostream& stm) bool ModelPrinter::isEquality(Literal* lit) { - CALL("ModelPrinter::isEquality"); - return lit->isEquality() || env.signature->getPredicate(lit->functor())->equalityProxy(); } @@ -125,8 +116,6 @@ bool ModelPrinter::isEquality(Literal* lit) */ void ModelPrinter::collectConstants(Literal* lit) { - CALL("ModelPrinter::collectConstants"); - SubtermIterator sti(lit); while(sti.hasNext()) { TermList t = sti.next(); @@ -144,8 +133,6 @@ void ModelPrinter::collectConstants(Literal* lit) void ModelPrinter::collectTrueLits() { - CALL("ModelPrinter::collectTrueLits"); - ClauseIterator ait = _iga.getActive(); while(ait.hasNext()) { Clause* cl = ait.next(); @@ -183,8 +170,6 @@ struct ModelPrinter::InstLitComparator void ModelPrinter::generateNewInstances(Literal* base, TermStack& domain, DHSet& instSet, LiteralStack& instAcc) { - CALL("ModelPrinter::generateNewInstances"); - //TODO: Add a smarted way of handling variables occurring multiple times!!! (now it's by MatchingUtils::match) unsigned arity = base->arity(); @@ -276,8 +261,6 @@ void ModelPrinter::generateNewInstances(Literal* base, TermStack& domain, DHSet< void ModelPrinter::getInstances(LiteralStack& trueLits, TermStack& domain, LiteralStack& instanceAcc) { - CALL("ModelPrinter::getInstances"); - static DHSet instSet; instSet.reset(); @@ -291,8 +274,6 @@ void ModelPrinter::getInstances(LiteralStack& trueLits, TermStack& domain, Liter void ModelPrinter::analyzeEqualityAndPopulateDomain() { - CALL("ModelPrinter::analyzeEqualityAndPopulateDomain"); - TermStack eqInstDomain = _usedConstants; LiteralStack eqInsts; getInstances(_trueEqs, eqInstDomain, eqInsts); @@ -349,8 +330,6 @@ void ModelPrinter::analyzeEqualityAndPopulateDomain() void ModelPrinter::rewriteLits(LiteralStack& lits) { - CALL("ModelPrinter::rewriteLits"); - static TermStack args; LiteralStack::Iterator iter(lits); @@ -382,7 +361,6 @@ void ModelPrinter::rewriteLits(LiteralStack& lits) void ModelPrinter::outputDomainSpec(ostream& out) { - CALL("ModelPrinter::outputDomainSpec"); ASS(_domain.isNonEmpty()); out << "fof(model1,interpretation_domain," << endl @@ -402,8 +380,6 @@ void ModelPrinter::outputDomainSpec(ostream& out) void ModelPrinter::outputFunInterpretations(ostream& out) { - CALL("ModelPrinter::outputFunInterpretations"); - if(_rewrites.isEmpty()) { return; } out << "fof(model2,interpretation_terms," << endl @@ -436,8 +412,6 @@ struct ModelPrinter::PredNumComparator void ModelPrinter::outputPredInterpretations(ostream& out) { - CALL("ModelPrinter::outputPredInterpretations"); - LiteralStack model; getInstances(_trueLits, _domain, model); diff --git a/Kernel/ApplicativeHelper.cpp b/Kernel/ApplicativeHelper.cpp index 065d5e048..dc4e6cb0a 100644 --- a/Kernel/ApplicativeHelper.cpp +++ b/Kernel/ApplicativeHelper.cpp @@ -22,16 +22,12 @@ using namespace Shell; TermList ApplicativeHelper::createAppTerm(TermList sort, TermList arg1, TermList arg2, TermList arg3, TermList arg4) { - CALL("ApplicativeHelper::createAppTerm/3"); - TermList t1 = createAppTerm3(sort, arg1, arg2, arg3); return createAppTerm(SortHelper::getResultSort(t1.term()), t1, arg4); } TermList ApplicativeHelper::createAppTerm3(TermList sort, TermList arg1, TermList arg2, TermList arg3) { - CALL("ApplicativeHelper::createAppTerm3"); - TermList s1 = getNthArg(sort, 1); TermList s2 = getResultApplieadToNArgs(sort, 1); TermList s3 = getNthArg(s2, 1); @@ -41,8 +37,6 @@ TermList ApplicativeHelper::createAppTerm3(TermList sort, TermList arg1, TermLis TermList ApplicativeHelper::createAppTerm(TermList sort, TermList arg1, TermList arg2) { - CALL("ApplicativeHelper::createAppTerm/2"); - TermList s1 = getNthArg(sort, 1); TermList s2 = getResultApplieadToNArgs(sort, 1); return createAppTerm(s1, s2, arg1, arg2); @@ -50,8 +44,6 @@ TermList ApplicativeHelper::createAppTerm(TermList sort, TermList arg1, TermList TermList ApplicativeHelper::createAppTerm(TermList s1, TermList s2, TermList arg1, TermList arg2, bool shared) { - CALL("ApplicativeHelper::createAppTerm/1"); - static TermStack args; args.reset(); args.push(s1); @@ -67,7 +59,6 @@ TermList ApplicativeHelper::createAppTerm(TermList s1, TermList s2, TermList arg TermList ApplicativeHelper::createAppTerm(TermList sort, TermList head, TermStack& terms) { - CALL("ApplicativeHelper::createAppTerm/4"); ASS(head.isVar() || SortHelper::getResultSort(head.term()) == sort); TermList res = head; @@ -85,7 +76,6 @@ TermList ApplicativeHelper::createAppTerm(TermList sort, TermList head, TermStac TermList ApplicativeHelper::createAppTerm(TermList sort, TermList head, TermList* args, unsigned arity, bool shared) { - CALL("ApplicativeHelper::createAppTerm/5"); ASS_REP(head.isVar() || SortHelper::getResultSort(head.term()) == sort, sort.toString() ); TermList res = head; @@ -104,8 +94,6 @@ TermList ApplicativeHelper::createAppTerm(TermList sort, TermList head, TermList /** indexed from 1 */ TermList ApplicativeHelper::getResultApplieadToNArgs(TermList arrowSort, unsigned argNum) { - CALL("ApplicativeHelper::getResultApplieadToNArgs"); - while(argNum > 0){ ASS(arrowSort.isArrowSort()); arrowSort = *arrowSort.term()->nthArgument(1); @@ -118,7 +106,6 @@ TermList ApplicativeHelper::getResultApplieadToNArgs(TermList arrowSort, unsigne /** indexed from 1 */ TermList ApplicativeHelper::getNthArg(TermList arrowSort, unsigned argNum) { - CALL("ApplicativeHelper::getNthArg"); ASS(argNum > 0); TermList res; @@ -133,8 +120,6 @@ TermList ApplicativeHelper::getNthArg(TermList arrowSort, unsigned argNum) TermList ApplicativeHelper::getResultSort(TermList sort) { - CALL("ApplicativeHelper::getResultSort"); - while(sort.isArrowSort()){ sort = *sort.term()->nthArgument(1); } @@ -143,8 +128,6 @@ TermList ApplicativeHelper::getResultSort(TermList sort) unsigned ApplicativeHelper::getArity(TermList sort) { - CALL("ApplicativeHelper::getArity"); - unsigned arity = 0; while(sort.isArrowSort()){ sort = *sort.term()->nthArgument(1); @@ -155,8 +138,6 @@ unsigned ApplicativeHelper::getArity(TermList sort) void ApplicativeHelper::getHeadAndAllArgs(TermList term, TermList& head, TermStack& args) { - CALL("ApplicativeHelper::getHeadAndAllArgs"); - while(term.isApplication()){ args.push(*term.term()->nthArgument(3)); term = *term.term()->nthArgument(2); @@ -173,8 +154,6 @@ void ApplicativeHelper::getHeadAndAllArgs(TermList term, TermList& head, TermSta void ApplicativeHelper::getHeadSortAndArgs(TermList term, TermList& head, TermList& headSort, TermStack& args) { - CALL("ApplicativeHelper::getHeadSortAndArgs"); - if(!args.isEmpty()){ args.reset(); } if(!term.isTerm()){ @@ -198,8 +177,6 @@ void ApplicativeHelper::getHeadSortAndArgs(TermList term, TermList& head, void ApplicativeHelper::getHeadAndArgs(TermList term, TermList& head, TermStack& args) { - CALL("ApplicativeHelper::getHeadAndArgs"); - if(!args.isEmpty()){ args.reset(); } while(term.isApplication()){ @@ -213,8 +190,6 @@ void ApplicativeHelper::getHeadAndArgs(TermList term, TermList& head, TermStack& void ApplicativeHelper::getHeadAndArgs(Term* term, TermList& head, TermStack& args) { - CALL("ApplicativeHelper::getHeadAndArgs/2"); - if(!args.isEmpty()){ args.reset(); } head = TermList(term); @@ -231,8 +206,6 @@ void ApplicativeHelper::getHeadAndArgs(Term* term, TermList& head, TermStack& ar void ApplicativeHelper::getHeadAndArgs(const Term* term, TermList& head, Deque& args) { - CALL("ApplicativeHelper::getHeadAndArgs/3"); - ASS(term->isApplication()); if(!args.isEmpty()){ args.reset(); } @@ -250,8 +223,6 @@ void ApplicativeHelper::getHeadAndArgs(const Term* term, TermList& head, DequeisApplication()){ trm = *t->nthArgument(2); @@ -278,20 +247,17 @@ TermList ApplicativeHelper::getHead(Term* t) bool ApplicativeHelper::isComb(const TermList head) { - CALL("ApplicativeHelper::isComb"); if(head.isVar()){ return false; } return env.signature->getFunction(head.term()->functor())->combinator() != Signature::NOT_COMB; } Signature::Combinator ApplicativeHelper::getComb (const TermList head) { - CALL("ApplicativeHelper::getComb"); return env.signature->getFunction(head.term()->functor())->combinator(); } Signature::Proxy ApplicativeHelper::getProxy(const TermList t) { - CALL("ApplicativeHelper::getProxy"); if(t.isVar()){ return Signature::NOT_PROXY; } @@ -299,8 +265,6 @@ Signature::Proxy ApplicativeHelper::getProxy(const TermList t) } bool ApplicativeHelper::isUnderApplied(TermList head, unsigned argNum){ - CALL("ApplicativeHelper::isPartiallyAppliedComb"); - ASS(isComb(head)); Signature::Combinator c = getComb(head); return ((c == Signature::I_COMB && argNum < 1) || @@ -311,8 +275,6 @@ bool ApplicativeHelper::isUnderApplied(TermList head, unsigned argNum){ } bool ApplicativeHelper::isExactApplied(TermList head, unsigned argNum){ - CALL("ApplicativeHelper::isExactApplied"); - ASS(isComb(head)); Signature::Combinator c = getComb(head); return ((c == Signature::I_COMB && argNum == 1) || @@ -325,8 +287,6 @@ bool ApplicativeHelper::isExactApplied(TermList head, unsigned argNum){ bool ApplicativeHelper::isOverApplied(TermList head, unsigned argNum){ - CALL("ApplicativeHelper::isOverApplied"); - ASS(isComb(head)); Signature::Combinator c = getComb(head); return ((c == Signature::I_COMB && argNum > 1) || @@ -338,24 +298,19 @@ bool ApplicativeHelper::isOverApplied(TermList head, unsigned argNum){ } bool ApplicativeHelper::isBool(TermList t){ - CALL("ApplicativeHelper::isBool"); return isTrue(t) || isFalse(t); } bool ApplicativeHelper::isTrue(TermList term){ - CALL("ApplicativeHelper::isTrue"); return term.isTerm() && env.signature->isFoolConstantSymbol(true, term.term()->functor()); } bool ApplicativeHelper::isFalse(TermList term){ - CALL("ApplicativeHelper::isFalse"); return term.isTerm() && env.signature->isFoolConstantSymbol(false, term.term()->functor()); } bool ApplicativeHelper::isSafe(TermStack& args) { - CALL("ApplicativeHelper::isSafe"); - for(unsigned i = 0; i < args.size(); i++){ TermList ithArg = args[i]; /*if(ithArg.isVar() || !ithArg.term()->ground()){ @@ -371,8 +326,6 @@ bool ApplicativeHelper::isSafe(TermStack& args) TermList ApplicativeHelper::replaceFunctionalAndBooleanSubterms(Term* term, FuncSubtermMap* fsm) { - CALL("TermSubstitutionTree::replaceFunctionalAndBooleanSubterms"); - typedef SmartPtr ArgsIt_ptr; typedef ApplicativeHelper AH; @@ -460,4 +413,4 @@ TermList ApplicativeHelper::replaceFunctionalAndBooleanSubterms(Term* term, Func TermList replaced = AH::createAppTerm(hoti.headSort, hoti.head, argLst, hoti.argNum, false); //cout << "new " + replaced.toString() << endl; return replaced; -} \ No newline at end of file +} diff --git a/Kernel/BestLiteralSelector.hpp b/Kernel/BestLiteralSelector.hpp index 92dbcdfe7..2a458dd82 100644 --- a/Kernel/BestLiteralSelector.hpp +++ b/Kernel/BestLiteralSelector.hpp @@ -59,8 +59,6 @@ class BestLiteralSelector BestLiteralSelector(const Ordering& ordering, const Options& options) : LiteralSelector(ordering, options) { - CALL("BestLiteralSelector::BestLiteralSelector"); - _comp.attachSelector(this); } @@ -68,8 +66,6 @@ class BestLiteralSelector protected: void doSelection(Clause* c, unsigned eligible) override { - CALL("BestLiteralSelector::doSelection"); - unsigned besti=0; Literal* best=(*c)[0]; for(unsigned i=1;icombinatorySup(); @@ -248,7 +241,6 @@ class CompleteBestLiteralSelector void fillMaximals(LiteralList*& maximals, DArray litArr) { - CALL("CompleteBestLiteralSelector::fillMaximals"); DArray::ReversedIterator rlit(litArr); while(rlit.hasNext()) { Literal* lit=rlit.next(); @@ -259,8 +251,6 @@ class CompleteBestLiteralSelector bool canBeSelected(Literal* lit, Set* maxTermHeads) { - CALL("CompleteBestLiteralSelector::canBeSelected"); - // TODO: // - fsi always returns terms only.therefore the whole implementation would always return true anyways, so we can comment out this code. // - this was discovered during a refactoring. Why was this function here in the first place? diff --git a/Kernel/BottomUpEvaluation.hpp b/Kernel/BottomUpEvaluation.hpp index afa19a764..ab60fccb2 100644 --- a/Kernel/BottomUpEvaluation.hpp +++ b/Kernel/BottomUpEvaluation.hpp @@ -119,7 +119,6 @@ template BottomUpChildIter bottomUpChildIter(A a) template typename EvalFn::Result evaluateBottomUp(typename EvalFn::Arg const& term, EvalFn evaluateStep, Memo& memo) { - CALL("evaluateBottomUp(...)") using Result = typename EvalFn::Result; using Arg = typename EvalFn::Arg; @@ -148,7 +147,6 @@ typename EvalFn::Result evaluateBottomUp(typename EvalFn::Arg const& term, EvalF BottomUpChildIter orig = recState->pop(); Result eval = memo.getOrInit(orig.self(), [&](){ - CALL("evaluateBottomUp(..)::closure@1") Result* argLst = NULL; if (orig.nChildren() != 0) { ASS_GE(recResults->size(), orig.nChildren()); diff --git a/Kernel/Clause.cpp b/Kernel/Clause.cpp index d520fce59..3518370e8 100644 --- a/Kernel/Clause.cpp +++ b/Kernel/Clause.cpp @@ -90,7 +90,6 @@ Clause::Clause(unsigned length,const Inference& inf) */ void* Clause::operator new(size_t sz, unsigned lits) { - CALL("Clause::operator new"); ASS_EQ(sz,sizeof(Clause)); RSTAT_CTR_INC("clauses created"); @@ -106,8 +105,6 @@ void* Clause::operator new(size_t sz, unsigned lits) void Clause::operator delete(void* ptr,unsigned length) { - CALL("Clause::operator delete"); - RSTAT_CTR_INC("clauses deleted by delete operator"); //We have to get sizeof(Clause) + (_length-1)*sizeof(Literal*) @@ -139,8 +136,6 @@ void Clause::destroyExceptInferenceObject() Clause* Clause::fromStack(const Stack& lits, const Inference& inf) { - CALL("Clause::fromStack"); - unsigned clen = lits.size(); Clause* res = new (clen) Clause(clen, inf); @@ -161,8 +156,6 @@ Clause* Clause::fromStack(const Stack& lits, const Inference& inf) */ Clause* Clause::fromClause(Clause* c) { - CALL("Clause::fromClause"); - Clause* res = fromIterator(Clause::Iterator(*c), SimplifyingInference1(InferenceRule::REORDER_LITERALS, c)); if (c->splits()) { @@ -196,8 +189,6 @@ void Clause::destroyIfUnnecessary() */ void Clause::destroy() { - CALL("Clause::destroy"); - static Stack toDestroy(32); Clause* cl = this; for(;;) { @@ -228,8 +219,6 @@ void Clause::destroy() * and there Clause's reference counter is zero. */ void Clause::setStore(Store s) { - CALL("Clause::setStore"); - #if VDEBUG //assure there is one selected clause static Clause* selected=0; @@ -251,8 +240,6 @@ void Clause::setStore(Store s) */ bool Clause::isGround() { - CALL("Clause::isGround"); - Iterator it(*this); while (it.hasNext()) { if (!it.next()->ground()) { @@ -267,8 +254,6 @@ bool Clause::isGround() */ bool Clause::isPropositional() { - CALL("Clause::isPropositional"); - Iterator it(*this); while (it.hasNext()) { if (it.next()->arity() > 0) { @@ -283,8 +268,6 @@ bool Clause::isPropositional() */ bool Clause::isHorn() { - CALL("Clause::isHorn"); - bool posFound=false; Iterator it(*this); while (it.hasNext()) { @@ -305,8 +288,6 @@ bool Clause::isHorn() */ VirtualIterator Clause::getVariableIterator() { - CALL("Clause::getVariableIterator"); - return pvi( getUniquePersistentIterator( getMappingIterator( getMapAndFlattenIterator( @@ -321,8 +302,6 @@ VirtualIterator Clause::getVariableIterator() */ bool Clause::noSplits() const { - CALL("Clause::noSplits"); - return !_inference.splits() || _inference.splits()->isEmpty(); } @@ -331,8 +310,6 @@ bool Clause::noSplits() const */ vstring Clause::literalsOnlyToString() const { - CALL("Clause::literalsOnlyToString"); - if (_length == 0) { return "$false"; } else { @@ -353,8 +330,6 @@ vstring Clause::literalsOnlyToString() const */ vstring Clause::toTPTPString() const { - CALL("Clause::toTPTPString()"); - vstring result = literalsOnlyToString(); return result; @@ -365,8 +340,6 @@ vstring Clause::toTPTPString() const */ vstring Clause::toNiceString() const { - CALL("Clause::toNiceString()"); - vstring result = literalsOnlyToString(); if (splits() && !splits()->isEmpty()) { @@ -382,8 +355,6 @@ vstring Clause::toNiceString() const */ vstring Clause::toString() const { - CALL("Clause::toString()"); - // print id and literals of clause vstring result = Int::toString(_number) + ". " + literalsOnlyToString(); @@ -446,7 +417,6 @@ vstring Clause::toString() const */ VirtualIterator Clause::toSimpleClauseStrings() { - CALL("toSimpleClauseStrings"); return pvi(getSingletonIterator(literalsOnlyToString())); } @@ -473,7 +443,6 @@ bool Clause::skip() const */ void Clause::computeColor() const { - CALL("Clause::computeColor"); ASS_EQ(_color, COLOR_INVALID); Color color = COLOR_TRANSPARENT; @@ -497,8 +466,6 @@ void Clause::computeColor() const */ unsigned Clause::computeWeight() const { - CALL("Clause::computeWeight"); - unsigned result = 0; for (int i = _length-1; i >= 0; i--) { ASS(_literals[i]->shared()); @@ -530,8 +497,6 @@ unsigned Clause::splitWeight() const */ unsigned Clause::getNumeralWeight() const { - CALL("Clause::getNumeralWeight"); - unsigned res = 0; Iterator litIt(*this); while (litIt.hasNext()) { @@ -583,8 +548,6 @@ unsigned Clause::getNumeralWeight() const { */ unsigned Clause::computeWeightForClauseSelection(const Options& opt) const { - CALL("Clause::computeWeightForClauseSelection"); - unsigned w = 0; if (_weight) { w = _weight; @@ -627,8 +590,6 @@ unsigned Clause::computeWeightForClauseSelection(const Options& opt) const */ unsigned Clause::computeWeightForClauseSelection(unsigned w, unsigned splitWeight, unsigned numeralWeight, bool derivedFromGoal, const Shell::Options& opt) { - CALL("Clause::computeWeightForClauseSelection(unsigned w, ...)"); - static unsigned nongoalWeightCoeffNum = opt.nongoalWeightCoefficientNumerator(); static unsigned nongoalWeightCoefDenom = opt.nongoalWeightCoefficientDenominator(); @@ -643,21 +604,17 @@ unsigned Clause::computeWeightForClauseSelection(unsigned w, unsigned splitWeigh void Clause::collectUnstableVars(DHSet& acc) { - CALL("Clause::collectUnstableVars"); collectVars2(acc); } void Clause::collectVars(DHSet& acc) { - CALL("Clause::collectVars"); collectVars2(acc); } template void Clause::collectVars2(DHSet& acc) { - CALL("Clause::collectVars2"); - Iterator it(*this); while (it.hasNext()) { Literal* lit = it.next(); @@ -672,8 +629,6 @@ void Clause::collectVars2(DHSet& acc) unsigned Clause::varCnt() { - CALL("Clause::varCnt"); - static DHSet vars; vars.reset(); collectVars(vars); @@ -682,8 +637,6 @@ unsigned Clause::varCnt() unsigned Clause::maxVar() { - CALL("Clause::maxVar()"); - unsigned max = 0; VirtualIterator it = getVariableIterator(); @@ -696,7 +649,6 @@ unsigned Clause::maxVar() unsigned Clause::numPositiveLiterals() { - CALL("Clause::numPositiveLiterals"); unsigned count = 0; for (int i = 0; i < _length; i++) { @@ -755,7 +707,6 @@ unsigned Clause::getLiteralPosition(Literal* lit) */ void Clause::notifyLiteralReorder() { - CALL("Clause::notifyLiteralReorder"); if (_literalPositions) { _literalPositions->update(_literals); } diff --git a/Kernel/Clause.hpp b/Kernel/Clause.hpp index 77eeeb1e5..7c0569fa9 100644 --- a/Kernel/Clause.hpp +++ b/Kernel/Clause.hpp @@ -86,8 +86,6 @@ class Clause template static Clause* fromIterator(Iter litit, const Inference& inf) { - CALL("Clause::fromIterator"); - static Stack st; st.reset(); st.loadFromIterator(litit); @@ -209,8 +207,6 @@ class Clause void incRefCnt() { _refCnt++; } void decRefCnt() { - CALL("Clause::decRefCnt"); - ASS_G(_refCnt,0); _refCnt--; destroyIfUnnecessary(); @@ -262,8 +258,6 @@ class Clause * computed and cached (which happens at the first call to weight()) */ void setSplits(SplitSet* splits) { - CALL("Clause::setSplits"); - ASS(_weight == 0); _inference.setSplits(splits); } diff --git a/Kernel/ClauseQueue.cpp b/Kernel/ClauseQueue.cpp index 1c0a5cdbd..c8414ea70 100644 --- a/Kernel/ClauseQueue.cpp +++ b/Kernel/ClauseQueue.cpp @@ -13,7 +13,6 @@ * @since 30/12/2007 Manchester */ -#include "Debug/Tracer.hpp" #include "Lib/Allocator.hpp" #include "Lib/Random.hpp" @@ -42,8 +41,6 @@ ClauseQueue::ClauseQueue() /** Temporary!!! */ ClauseQueue::~ClauseQueue () { - CALL("ClauseQueue::~ClauseQueue"); - removeAll(); DEALLOC_KNOWN(_left,sizeof(Node)+MAX_HEIGHT*sizeof(Node*),"ClauseQueue::Node"); @@ -55,8 +52,6 @@ ClauseQueue::~ClauseQueue () */ void ClauseQueue::insert(Clause* c) { - CALL("ClauseQueue::insert"); - // select a random height between 0 and top unsigned h = 0; while (Random::getBit()) { @@ -103,8 +98,6 @@ void ClauseQueue::insert(Clause* c) */ bool ClauseQueue::remove(Clause* c) { - CALL("ClauseQueue::remove"); - unsigned h = _height; Node* left = _left; @@ -160,7 +153,6 @@ bool ClauseQueue::remove(Clause* c) */ Clause* ClauseQueue::pop() { - CALL("ClauseQueue::pop"); ASS(_height >= 0); ASS(_left->nodes[0] != 0); @@ -191,8 +183,6 @@ Clause* ClauseQueue::pop() */ void ClauseQueue::removeAll() { - CALL("ClauseQueue::removeAll"); - while (_left->nodes[0]) { pop(); } diff --git a/Kernel/ColorHelper.cpp b/Kernel/ColorHelper.cpp index fc5b5bc31..d04adddbf 100644 --- a/Kernel/ColorHelper.cpp +++ b/Kernel/ColorHelper.cpp @@ -39,8 +39,6 @@ namespace Kernel */ bool ColorHelper::isTransparent(bool predicate, unsigned functor) { - CALL("ColorHelper::isTransparent"); - Signature::Symbol* sym; if (predicate) { sym = env.signature->getPredicate(functor); @@ -53,8 +51,6 @@ bool ColorHelper::isTransparent(bool predicate, unsigned functor) bool ColorHelper::hasColoredPredicates(Clause* c) { - CALL("ColorHelper::hasColoredPredicates"); - unsigned clen = c->length(); for (unsigned i=0; i& acc) { - CALL("ColorHelper::collectColoredConstants"); - unsigned clen = c->length(); for (unsigned i=0; i& acc) Clause* ColorHelper::skolemizeColoredConstants(Clause* c) { - CALL("ColorHelper::skolemizeColoredConstants"); - Stack coloredConstants; collectColoredConstants(c,coloredConstants); if (coloredConstants.isEmpty()) { @@ -126,8 +118,6 @@ Clause* ColorHelper::skolemizeColoredConstants(Clause* c) void ColorHelper::ensureSkolemReplacement(Term* t, TermMap& map) { - CALL("ColorHelper::ensureSkolemReplacement"); - //TODO: check also for generalization, or even better, first //find the most general colored terms, and make skolem replacements //only for those @@ -152,8 +142,6 @@ void ColorHelper::ensureSkolemReplacement(Term* t, TermMap& map) void ColorHelper::collectSkolemReplacements(Clause* c, TermMap& map) { - CALL("ColorHelper::collectSkolemReplacements"); - unsigned clen = c->length(); for (unsigned i=0; i(c1|c2); } @@ -48,7 +47,6 @@ class ColorHelper { * and the other is @c COLOR_RIGHT. */ static bool compatible(Color c1, Color c2) { - CALL("ColorHelper::compatible"); return combine(c1,c2)!=COLOR_INVALID; } diff --git a/Kernel/ELiteralSelector.cpp b/Kernel/ELiteralSelector.cpp index c4368dc9b..ad0e4c0c3 100644 --- a/Kernel/ELiteralSelector.cpp +++ b/Kernel/ELiteralSelector.cpp @@ -27,8 +27,6 @@ using namespace Kernel; LiteralList* ELiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligible) { - CALL("ELiteralSelector::getMaximalsInOrder"); - LiteralList* res = LiteralList::empty(); for(int li=((int)eligible)-1; li>=0; li--) { @@ -42,8 +40,6 @@ LiteralList* ELiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligible) unsigned ELiteralSelector::lit_standard_diff(Literal* lit) { - CALL("ELiteralSelector::lit_standard_diff"); - if (lit->isEquality()) { unsigned w0 = lit->nthArgument(0)->weight(); unsigned w1 = lit->nthArgument(1)->weight(); @@ -59,15 +55,11 @@ unsigned ELiteralSelector::lit_standard_diff(Literal* lit) */ unsigned ELiteralSelector::lit_sel_diff_weight(Literal* lit) { - CALL("ELiteralSelector::lit_sel_diff_weight"); - return 100*lit_standard_diff(lit)+lit->weight(); } void ELiteralSelector::doSelection(Clause* c, unsigned eligible) { - CALL("ELiteralSelector::doSelection"); - Literal* singleSel = nullptr; LiteralList* sel = LiteralList::empty(); diff --git a/Kernel/EqHelper.cpp b/Kernel/EqHelper.cpp index da6d9274e..4f095ca55 100644 --- a/Kernel/EqHelper.cpp +++ b/Kernel/EqHelper.cpp @@ -41,7 +41,6 @@ auto withEqualitySort(Literal* eq, TermListIter iter) */ TermList EqHelper::getOtherEqualitySide(Literal* eq, TermList lhs) { - CALL("EqHelper::getOtherEqualitySide"); ASS(eq->isEquality()); if (*eq->nthArgument(0) == lhs) { @@ -53,7 +52,6 @@ TermList EqHelper::getOtherEqualitySide(Literal* eq, TermList lhs) bool EqHelper::hasGreaterEqualitySide(Literal* eq, const Ordering& ord, TermList& lhs, TermList& rhs) { - CALL("EqHelper::hasGreaterEqualitySide"); ASS(eq->isEquality()); switch(ord.getEqualityArgumentOrder(eq)) { @@ -78,8 +76,6 @@ bool EqHelper::hasGreaterEqualitySide(Literal* eq, const Ordering& ord, TermList Literal* EqHelper::replace(Literal* lit, TermList what, TermList by) { - CALL("EqHelper::replace(Literal*,...)"); - return static_cast(replace(static_cast(lit), what, by)); } @@ -91,7 +87,6 @@ Literal* EqHelper::replace(Literal* lit, TermList what, TermList by) */ Term* EqHelper::replace(Term* trm0, TermList tSrc, TermList tDest) { - CALL("EqHelper::replace(Term*,...)"); ASS(trm0->shared()); ASS(!trm0->isSort()); ASS(tSrc.isVar() || !tSrc.term()->isSort()); @@ -180,25 +175,21 @@ Term* EqHelper::replace(Term* trm0, TermList tSrc, TermList tDest) VirtualIterator EqHelper::getSubtermIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getSubtermIterator"); return getRewritableSubtermIterator(lit, ord); } TermIterator EqHelper::getBooleanSubtermIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getSubtermIterator"); return getRewritableSubtermIterator(lit, ord); } VirtualIterator EqHelper::getFoSubtermIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getFoSubtermIterator"); return getRewritableSubtermIterator(lit, ord); } TermIterator EqHelper::getNarrowableSubtermIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getNarrowableSubtermIterator"); return getRewritableSubtermIterator(lit, ord); } @@ -207,8 +198,6 @@ TermIterator EqHelper::getNarrowableSubtermIterator(Literal* lit, const Ordering */ VirtualIterator EqHelper::getRewritableVarsIterator(DHSet* unstableVars, Literal* lit, const Ordering& ord) { - CALL("EqHelper::getNarrowableSubtermIterator"); - ASS(lit->isEquality()); TermList sel; @@ -246,8 +235,6 @@ VirtualIterator EqHelper::getRewritableVarsIterator(DHSet VirtualIterator EqHelper::getRewritableSubtermIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getRewritableSubtermIterator"); - if (lit->isEquality()) { TermList sel; switch(ord.getEqualityArgumentOrder(lit)) { @@ -289,8 +276,6 @@ VirtualIterator EqHelper::getRewritableSubtermIte */ VirtualIterator EqHelper::getLHSIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getLHSIterator"); - if (lit->isEquality()) { if (lit->isNegative()) { return withEqualitySort(lit,TermIterator::getEmpty()); @@ -335,8 +320,6 @@ struct EqHelper::IsNonVariable */ VirtualIterator EqHelper::getSuperpositionLHSIterator(Literal* lit, const Ordering& ord, const Options& opt) { - CALL("EqHelper::getSuperpositionLHSIterator"); - if (opt.superpositionFromVariables()) { return getLHSIterator(lit, ord); } @@ -349,8 +332,6 @@ VirtualIterator EqHelper::getSuperpositionLHSIterator(Literal* li VirtualIterator EqHelper::getSubVarSupLHSIterator(Literal* lit, const Ordering& ord) { - CALL("EqHelper::getSubVarSupLHSIterator"); - ASS(lit->isEquality()); TermList eqSort = SortHelper::getEqualityArgumentSort(lit); @@ -410,8 +391,6 @@ VirtualIterator EqHelper::getSubVarSupLHSIterator(Literal* lit, c */ VirtualIterator EqHelper::getDemodulationLHSIterator(Literal* lit, bool forward, const Ordering& ord, const Options& opt) { - CALL("EqHelper::getDemodulationLHSIterator"); - if (lit->isEquality()) { if (lit->isNegative()) { return withEqualitySort(lit, TermIterator::getEmpty()); @@ -456,7 +435,6 @@ VirtualIterator EqHelper::getDemodulationLHSIterator(Literal* lit TermIterator EqHelper::getEqualityArgumentIterator(Literal* lit) { - CALL("EqHelper::getEqualityArgumentIterator"); ASS(lit->isEquality()); return pvi( getConcatenatedIterator( diff --git a/Kernel/FlatTerm.cpp b/Kernel/FlatTerm.cpp index daf83f1d5..953982e1b 100644 --- a/Kernel/FlatTerm.cpp +++ b/Kernel/FlatTerm.cpp @@ -33,7 +33,6 @@ using namespace Lib; */ void* FlatTerm::operator new(size_t sz,unsigned num) { - CALL("FlatTerm::operator new"); ASS_GE(num,1); ASS_EQ(sz, sizeof(FlatTerm)); @@ -48,7 +47,6 @@ void* FlatTerm::operator new(size_t sz,unsigned num) */ void FlatTerm::destroy() { - CALL("FlatTerm::destroy"); ASS_GE(_length,1); //one entry is already accounted for in the size of the FlatTerm object @@ -60,7 +58,6 @@ void FlatTerm::destroy() FlatTerm::FlatTerm(size_t length) : _length(length) { - CALL("FlatTerm::FlatTerm"); } size_t FlatTerm::getEntryCount(Term* t) @@ -71,8 +68,6 @@ size_t FlatTerm::getEntryCount(Term* t) FlatTerm* FlatTerm::create(Term* t) { - CALL("FlatTerm::create(Term)"); - size_t entries=getEntryCount(t); FlatTerm* res=new(entries) FlatTerm(entries); @@ -104,8 +99,6 @@ FlatTerm* FlatTerm::create(Term* t) FlatTerm* FlatTerm::create(TermList t) { - CALL("FlatTerm::create(TermList)"); - if(t.isTerm()) { return create(t.term()); } @@ -120,8 +113,6 @@ FlatTerm* FlatTerm::create(TermList t) FlatTerm* FlatTerm::copy(const FlatTerm* ft) { - CALL("FlatTerm::copy"); - size_t entries=ft->_length; FlatTerm* res=new(entries) FlatTerm(entries); memcpy(res->_data, ft->_data, entries*sizeof(Entry)); @@ -130,7 +121,6 @@ FlatTerm* FlatTerm::copy(const FlatTerm* ft) void FlatTerm::swapCommutativePredicateArguments() { - CALL("FlatTerm::swapCommutativePredicateArguments"); ASS_EQ((*this)[0].tag(), FUN); ASS_EQ((*this)[0].number()|1, 1); //as for now, the only commutative predicate is equality diff --git a/Kernel/Formula.cpp b/Kernel/Formula.cpp index 4a8e7382a..e9296b373 100644 --- a/Kernel/Formula.cpp +++ b/Kernel/Formula.cpp @@ -31,8 +31,6 @@ vstring Formula::DEFAULT_LABEL = "none"; */ void Formula::destroy () { - CALL ("Formula::destroy"); - switch ( connective() ) { case LITERAL: delete static_cast(this); @@ -97,8 +95,6 @@ vstring Formula::toString (Connective c) */ vstring Formula::toString () const { - CALL("Formula::toString"); - vstring res; // render a connective if specified, and then a Formula (or ")" of formula is nullptr) @@ -244,8 +240,6 @@ vstring Formula::toString () const */ bool Formula::parenthesesRequired (Connective outer) const { - CALL("Formula::parenthesesRequired"); - switch (connective()) { case LITERAL: @@ -288,8 +282,6 @@ bool Formula::parenthesesRequired (Connective outer) const */ VList* Formula::freeVariables () const { - CALL("Formula::freeVariables"); - FormulaVarIterator fvi(this); VList* result = VList::empty(); VList::FIFO stack(result); @@ -301,8 +293,6 @@ VList* Formula::freeVariables () const bool Formula::isFreeVariable(unsigned var) const { - CALL("Formula::isFreeVariable"); - FormulaVarIterator fvi(this); while (fvi.hasNext()) { if (var == fvi.next()) { @@ -320,8 +310,6 @@ bool Formula::isFreeVariable(unsigned var) const */ VList* Formula::boundVariables () const { - CALL("Formula::boundVariables"); - VList* res = VList::empty(); SubformulaIterator sfit(const_cast(this)); while(sfit.hasNext()) { @@ -342,8 +330,6 @@ VList* Formula::boundVariables () const */ unsigned Formula::weight() const { - CALL("Formula::weight"); - unsigned result=0; SubformulaIterator fs(const_cast(this)); @@ -386,8 +372,6 @@ Formula* JunctionFormula::generalJunction(Connective c, FormulaList* args) */ Color Formula::getColor() { - CALL("Formula::getColor"); - SubformulaIterator si(this); while(si.hasNext()) { Formula* f=si.next(); @@ -408,8 +392,6 @@ Color Formula::getColor() */ bool Formula::getSkip() { - CALL("Formula::getColor"); - SubformulaIterator si(this); while(si.hasNext()) { Formula* f=si.next(); @@ -426,16 +408,12 @@ bool Formula::getSkip() Formula* Formula::trueFormula() { - CALL("Formula::trueFormula"); - static Formula* res = new Formula(true); return res; } Formula* Formula::falseFormula() { - CALL("Formula::falseFormula"); - static Formula* res = new Formula(false); return res; } @@ -446,7 +424,6 @@ Formula* Formula::falseFormula() */ Formula* Formula::createITE(Formula* condition, Formula* thenArg, Formula* elseArg) { - CALL("Formula::createITE"); TermList thenTerm(Term::createFormula(thenArg)); TermList elseTerm(Term::createFormula(elseArg)); TermList iteTerm(Term::createITE(condition, thenTerm, elseTerm, AtomicSort::boolSort())); @@ -460,7 +437,6 @@ Formula* Formula::createITE(Formula* condition, Formula* thenArg, Formula* elseA */ Formula* Formula::createLet(unsigned functor, VList* variables, TermList body, Formula* contents) { - CALL("Formula::createLet(TermList)"); TermList contentsTerm(Term::createFormula(contents)); TermList letTerm(Term::createLet(functor, variables, body, contentsTerm, AtomicSort::boolSort())); return new BoolTermFormula(letTerm); @@ -473,7 +449,6 @@ Formula* Formula::createLet(unsigned functor, VList* variables, TermList body, F */ Formula* Formula::createLet(unsigned predicate, VList* variables, Formula* body, Formula* contents) { - CALL("Formula::createLet(Formula*)"); TermList bodyTerm(Term::createFormula(body)); TermList contentsTerm(Term::createFormula(contents)); TermList letTerm(Term::createLet(predicate, variables, bodyTerm, contentsTerm, AtomicSort::boolSort())); @@ -519,8 +494,6 @@ Formula* Formula::quantify(Formula* f) */ Formula* Formula::fromClause(Clause* cl) { - CALL("Formula::fromClause"); - FormulaList* resLst=0; unsigned clen=cl->length(); for(unsigned i=0;itoString(); } diff --git a/Kernel/FormulaTransformer.cpp b/Kernel/FormulaTransformer.cpp index 4ea7f57f7..ff0f3d1ed 100644 --- a/Kernel/FormulaTransformer.cpp +++ b/Kernel/FormulaTransformer.cpp @@ -28,7 +28,6 @@ namespace Kernel { Formula* FormulaTransformer::transform(Formula* f) { - CALL("FormulaTransformer::transform"); Formula* res = apply(f); return res; } @@ -36,8 +35,6 @@ Formula* FormulaTransformer::transform(Formula* f) { Formula* FormulaTransformer::apply(Formula* f) { - CALL("FormulaTransformer::apply(Formula*)"); - if(!preApply(f)) { return f; } @@ -88,8 +85,6 @@ Formula* FormulaTransformer::apply(Formula* f) } TermList FormulaTransformer::apply(TermList ts) { - CALL("FormulaTransformer::apply(TermList)"); - if (ts.isVar()) { return ts; } @@ -154,8 +149,6 @@ TermList FormulaTransformer::apply(TermList ts) { Formula* FormulaTransformer::applyJunction(Formula* f) { - CALL("FormulaTransformer::applyJunction"); - Connective con = f->connective(); FormulaList* resArgs = 0; @@ -186,8 +179,6 @@ Formula* FormulaTransformer::applyJunction(Formula* f) Formula* FormulaTransformer::applyNot(Formula* f) { - CALL("FormulaTransformer::applyNot"); - Formula* newArg = apply(f->uarg()); if(newArg==f->uarg()) { return f; @@ -200,8 +191,6 @@ Formula* FormulaTransformer::applyNot(Formula* f) Formula* FormulaTransformer::applyBinary(Formula* f) { - CALL("FormulaTransformer::applyBinary"); - Formula* newLeft = apply(f->left()); Formula* newRight = apply(f->right()); if(newLeft==f->left() && newRight==f->right()) { @@ -212,8 +201,6 @@ Formula* FormulaTransformer::applyBinary(Formula* f) Formula* FormulaTransformer::applyQuantified(Formula* f) { - CALL("FormulaTransformer::applyQuantified"); - Formula* newArg = apply(f->qarg()); if(newArg==f->qarg()) { return f; @@ -228,8 +215,6 @@ Formula* FormulaTransformer::applyQuantified(Formula* f) Formula* TermTransformingFormulaTransformer::applyLiteral(Formula* f) { - CALL("TermTransformingFormulaTransformer::applyLiteral"); - Literal* lit = f->literal(); Literal* res = _termTransformer.transform(lit); if(lit==res) { return f; } @@ -242,8 +227,6 @@ Formula* TermTransformingFormulaTransformer::applyLiteral(Formula* f) Formula* BottomUpTermTransformerFormulaTransformer::applyLiteral(Formula* f) { - CALL("TermTransformingFormulaTransformer::applyLiteral"); - Literal* lit = f->literal(); Literal* res = _termTransformer.transform(lit); if(lit==res) { return f; } @@ -256,14 +239,11 @@ Formula* BottomUpTermTransformerFormulaTransformer::applyLiteral(Formula* f) TermList PolarityAwareFormulaTransformer::getVarSort(unsigned var) const { - CALL("PolarityAwareFormulaTransformer::getVarSort"); - return _varSorts->get(var, AtomicSort::defaultSort()); } Formula* PolarityAwareFormulaTransformer::transformWithPolarity(Formula* f, int polarity) { - CALL("PolarityAwareFormulaTransformer::transform"); ASS_REP(polarity==0 || polarity==1 || polarity==-1, polarity); _varSorts->reset(); @@ -275,15 +255,12 @@ Formula* PolarityAwareFormulaTransformer::transformWithPolarity(Formula* f, int Formula* PolarityAwareFormulaTransformer::applyNot(Formula* f) { - CALL("PolarityAwareFormulaTransformer::applyNot"); - ScopedLet plet(_polarity, -_polarity); return FormulaTransformer::applyNot(f); } Formula* PolarityAwareFormulaTransformer::applyImp(Formula* f) { - CALL("PolarityAwareFormulaTransformer::applyImp"); ASS_EQ(f->connective(),IMP); Formula* newLeft; @@ -304,7 +281,6 @@ Formula* PolarityAwareFormulaTransformer::applyImp(Formula* f) */ Formula* PolarityAwareFormulaTransformer::applyBinary(Formula* f) { - CALL("PolarityAwareFormulaTransformer::applyBinary"); ASS(f->connective()==IFF || f->connective()==XOR); ScopedLet plet(_polarity, 0); @@ -317,8 +293,6 @@ Formula* PolarityAwareFormulaTransformer::applyBinary(Formula* f) void FormulaUnitTransformer::transform(UnitList*& units) { - CALL("FormulaUnitTransformer::transform(UnitList*&)"); - UnitList::DelIterator uit(units); while(uit.hasNext()) { Unit* u = uit.next(); @@ -345,8 +319,6 @@ void FormulaUnitTransformer::transform(UnitList*& units) FormulaUnit* LocalFormulaUnitTransformer::transform(FormulaUnit* unit) { - CALL("LocalFormulaUnitTransformer::transform(FormulaUnit*)"); - Formula* f = unit->formula(); Formula* newForm = transform(f); if(f==newForm) { @@ -362,8 +334,6 @@ FormulaUnit* LocalFormulaUnitTransformer::transform(FormulaUnit* unit) void ScanAndApplyFormulaUnitTransformer::apply(Problem& prb) { - CALL("ScanAndApplyFormulaUnitTransformer::apply(Problem&)"); - if(apply(prb.units())) { updateModifiedProblem(prb); } @@ -371,8 +341,6 @@ void ScanAndApplyFormulaUnitTransformer::apply(Problem& prb) bool ScanAndApplyFormulaUnitTransformer::apply(UnitList*& units) { - CALL("ScanAndApplyFormulaUnitTransformer::apply(UnitList*&)"); - scan(units); bool modified = false; @@ -405,8 +373,6 @@ bool ScanAndApplyFormulaUnitTransformer::apply(UnitList*& units) bool ScanAndApplyFormulaUnitTransformer::apply(Unit* u, Unit*& res) { - CALL("ScanAndApplyFormulaUnitTransformer::apply(Unit*,Unit*&)"); - if(u->isClause()) { Clause* cl = static_cast(u); return apply(cl, res); @@ -419,8 +385,6 @@ bool ScanAndApplyFormulaUnitTransformer::apply(Unit* u, Unit*& res) void ScanAndApplyFormulaUnitTransformer::updateModifiedProblem(Problem& prb) { - CALL("ScanAndApplyFormulaUnitTransformer::updateModifiedProblem"); - prb.invalidateEverything(); } diff --git a/Kernel/FormulaTransformer.hpp b/Kernel/FormulaTransformer.hpp index b1516917a..a805555d8 100644 --- a/Kernel/FormulaTransformer.hpp +++ b/Kernel/FormulaTransformer.hpp @@ -160,7 +160,6 @@ class FTFormulaUnitTransformer : public LocalFormulaUnitTransformer virtual Formula* transform(Formula* f) { - CALL("FTFormulaUnitTransformer::transform(Formula*)"); return _formulaTransformer.transform(f); } diff --git a/Kernel/FormulaUnit.cpp b/Kernel/FormulaUnit.cpp index 07c6d2ec1..88c6d5f8b 100644 --- a/Kernel/FormulaUnit.cpp +++ b/Kernel/FormulaUnit.cpp @@ -50,8 +50,6 @@ vstring FormulaUnit::toString() const unsigned FormulaUnit::varCnt() { - CALL("FormulaUnit::varCnt"); - Formula* frm = formula(); VList* fv = frm->freeVariables(); VList* bv = frm->boundVariables(); @@ -70,7 +68,6 @@ unsigned FormulaUnit::varCnt() */ Color FormulaUnit::getColor() { - CALL("FormulaUnit::getColor"); ASS_ALLOC_TYPE(this, "FormulaUnit"); if (_cachedColor == COLOR_INVALID) { @@ -81,7 +78,6 @@ Color FormulaUnit::getColor() unsigned FormulaUnit::weight() { - CALL("FormulaUnit::weight"); ASS_ALLOC_TYPE(this, "FormulaUnit"); if (!_cachedWeight) { diff --git a/Kernel/FormulaVarIterator.cpp b/Kernel/FormulaVarIterator.cpp index 41b0cda95..c158c4c42 100644 --- a/Kernel/FormulaVarIterator.cpp +++ b/Kernel/FormulaVarIterator.cpp @@ -18,7 +18,6 @@ * @since 15/05/2015 Gothenburg, FOOL support added */ -#include "Debug/Tracer.hpp" #include "FormulaVarIterator.hpp" @@ -43,7 +42,6 @@ FormulaVarIterator::FormulaVarIterator(const Formula* f) FormulaVarIterator::FormulaVarIterator(const Term* t) : _found(false) { - CALL("FormulaVarIterator::FormulaVarIterator(Term*)"); _instructions.push(FVI_TERM); _terms.push(t); } // FormulaVarIterator::FormulaVarIterator @@ -55,7 +53,6 @@ FormulaVarIterator::FormulaVarIterator(const Term* t) FormulaVarIterator::FormulaVarIterator(const TermList* ts) : _found(false) { - CALL("FormulaVarIterator::FormulaVarIterator(TermList)"); _instructions.push(FVI_TERM_LIST); _termLists.push(*ts); } // FormulaVarIterator::FormulaVarIterator @@ -66,8 +63,6 @@ FormulaVarIterator::FormulaVarIterator(const TermList* ts) */ unsigned FormulaVarIterator::next() { - CALL("FormulaVarIterator::next"); - ASS(_found); _found = false; return _nextVar; @@ -81,8 +76,6 @@ unsigned FormulaVarIterator::next() */ bool FormulaVarIterator::hasNext() { - CALL("FormulaVarIterator::hasNext"); - if (_found) return true; while (_instructions.isNonEmpty()) { diff --git a/Kernel/Grounder.cpp b/Kernel/Grounder.cpp index bf0a26714..489981122 100644 --- a/Kernel/Grounder.cpp +++ b/Kernel/Grounder.cpp @@ -41,8 +41,6 @@ using namespace Kernel; */ SATClause* Grounder::ground(Clause* cl) { - CALL("Grounder::ground(Clause*)"); - if(!cl->noSplits()) { NOT_IMPLEMENTED; } @@ -71,8 +69,6 @@ SATClause* Grounder::ground(Clause* cl) */ void Grounder::groundNonProp(Clause* cl, SATLiteralStack& acc, Literal** normLits) { - CALL("Grounder::groundNonProp/2"); - static DArray lits; unsigned clen = cl->length(); @@ -107,8 +103,6 @@ void Grounder::groundNonProp(Clause* cl, SATLiteralStack& acc, Literal** normLit */ SATClause* Grounder::groundNonProp(Clause* cl, Literal** normLits) { - CALL("Grounder::groundNonProp(Clause*,Literal**)"); - static SATLiteralStack gndLits; gndLits.reset(); @@ -123,8 +117,6 @@ SATClause* Grounder::groundNonProp(Clause* cl, Literal** normLits) */ SATLiteral Grounder::groundLiteral(Literal* lit) { - CALL("Grounder::ground(Literal*)"); - Literal* norm = lit; normalize(1, &norm); SATLiteral slit = groundNormalized(norm); @@ -136,8 +128,6 @@ SATLiteral Grounder::groundLiteral(Literal* lit) */ SATLiteral Grounder::groundNormalized(Literal* lit) { - CALL("Grounder::groundNormalized"); - bool isPos = lit->isPositive(); Literal* posLit = Literal::positiveLiteral(lit); @@ -150,8 +140,6 @@ SATLiteral Grounder::groundNormalized(Literal* lit) LiteralIterator Grounder::groundedLits() { - CALL("Grounder::groundedLits"); - return _asgn.domain(); } @@ -202,8 +190,6 @@ struct GlobalSubsumptionGrounder::OrderNormalizingComparator void GlobalSubsumptionGrounder::normalize(unsigned cnt, Literal** lits) { - CALL("GlobalSubsumptionGrounder::normalize"); - if(!_doNormalization) { return; } if(cnt==0) { return; } @@ -263,16 +249,12 @@ class IGGrounder::CollapsingApplicator */ Literal* IGGrounder::collapseVars(Literal* lit) { - CALL("IGGrounder::collapseVars"); - CollapsingApplicator apl(_tgtTerm); return SubstHelper::apply(lit, apl); } void IGGrounder::normalize(unsigned cnt, Literal** lits) { - CALL("IGGrounder::normalize"); - for(unsigned i=0; i(std::max(toNumber(t1), toNumber(t2))); } @@ -46,7 +43,6 @@ UnitInputType Kernel::getInputType(UnitInputType t1, UnitInputType t2) */ UnitInputType Kernel::getInputType(UnitList* units) { - CALL("Inference::getInputType"); ASS(units); UnitList::Iterator uit(units); @@ -76,8 +72,6 @@ struct FromSatRefutationInfo { void Inference::destroyDirectlyOwned() { - CALL("Inference::destroyDirectlyOwned"); - switch(_kind) { case Kind::INFERENCE_FROM_SAT_REFUTATION: delete static_cast(_ptr2); @@ -91,8 +85,6 @@ void Inference::destroyDirectlyOwned() void Inference::destroy() { - CALL("Inference::destroy"); - switch(_kind) { case Kind::INFERENCE_012: if (_ptr1) static_cast(_ptr1)->decRefCnt(); @@ -114,8 +106,6 @@ void Inference::destroy() } Inference::Inference(const FromSatRefutation& fsr) { - CALL("Inference::Inference(FromSatRefutation)"); - initMany(fsr._rule,fsr._premises); ASS_REP(isSatRefutationRule(fsr._rule),ruleName(fsr._rule)); @@ -134,8 +124,6 @@ Inference::Inference(const FromSatRefutation& fsr) { */ Inference::Iterator Inference::iterator() const { - CALL("Inference::iterator"); - Iterator it; switch(_kind) { case Kind::INFERENCE_012: @@ -156,8 +144,6 @@ Inference::Iterator Inference::iterator() const */ bool Inference::hasNext(Iterator& it) const { - CALL("Inference::hasNext"); - switch(_kind) { case Kind::INFERENCE_012: switch(it.integer) { @@ -186,8 +172,6 @@ bool Inference::hasNext(Iterator& it) const */ Unit* Inference::next(Iterator& it) const { - CALL("Inference::next"); - switch(_kind) { case Kind::INFERENCE_012: switch(it.integer) { @@ -216,8 +200,6 @@ Unit* Inference::next(Iterator& it) const void Inference::updateStatistics() { - CALL("Inference::updateStatistics"); - switch(_kind) { case Kind::INFERENCE_012: if (_ptr1 == nullptr) { @@ -260,8 +242,6 @@ void Inference::updateStatistics() vstring Inference::toString() const { - CALL("Inference::toString"); - vstring result; switch(_kind) { @@ -307,8 +287,6 @@ vstring Inference::toString() const void Inference::init0(UnitInputType inputType, InferenceRule r) { - CALL("Inference::init0"); - initDefault(inputType,r); _kind = Kind::INFERENCE_012; _ptr1 = nullptr; @@ -327,8 +305,6 @@ void Inference::init0(UnitInputType inputType, InferenceRule r) void Inference::init1(InferenceRule r, Unit* premise) { - CALL("Inference::init1"); - initDefault(premise->inputType(),r); _kind = Kind::INFERENCE_012; @@ -349,8 +325,6 @@ void Inference::init1(InferenceRule r, Unit* premise) void Inference::init2(InferenceRule r, Unit* premise1, Unit* premise2) { - CALL("Inference::init2"); - initDefault(getInputType(premise1->inputType(),premise2->inputType()),r); _kind = Kind::INFERENCE_012; @@ -372,8 +346,6 @@ void Inference::init2(InferenceRule r, Unit* premise1, Unit* premise2) void Inference::initMany(InferenceRule r, UnitList* premises) { - CALL("Inference::initMany"); - initDefault(UnitInputType::AXIOM /* the minimal element; we later compute maximum over premises*/,r); _kind = Kind::INFERENCE_MANY; @@ -415,21 +387,15 @@ void Inference::initMany(InferenceRule r, UnitList* premises) } Inference::Inference(const FromInput& fi) { - CALL("Inference::Inference(FromInput)"); - init0(fi.inputType,InferenceRule::INPUT); } Inference::Inference(const TheoryAxiom& ta) { - CALL("Inference::Inference(TheoryAxiom)"); - init0(UnitInputType::AXIOM,ta.rule); ASS_REP(isInternalTheoryAxiomRule(ta.rule) || isExternalTheoryAxiomRule(ta.rule), ruleName(ta.rule)); } Inference::Inference(const FormulaTransformation& ft) { - CALL("Inference::Inference(FormulaTransformation)"); - init1(ft.rule,ft.premise); ASS_REP(isFormulaTransformation(ft.rule),ruleName(ft.rule)); @@ -439,8 +405,6 @@ Inference::Inference(const FormulaTransformation& ft) { } Inference::Inference(const FormulaTransformationMany& ft) { - CALL("Inference::Inference(FormulaTransformationMany)"); - initMany(ft.rule,ft.premises); ASS_REP(isFormulaTransformation(ft.rule),ruleName(ft.rule)); @@ -451,8 +415,6 @@ Inference::Inference(const FormulaTransformationMany& ft) { } Inference::Inference(const GeneratingInference1& gi) { - CALL("Inference::Inference(GeneratingInference1)"); - init1(gi.rule,gi.premise); ASS_REP(isGeneratingInferenceRule(gi.rule),ruleName(gi.rule)); @@ -462,8 +424,6 @@ Inference::Inference(const GeneratingInference1& gi) { } Inference::Inference(const GeneratingInference2& gi) { - CALL("Inference::Inference(GeneratingInference2)"); - init2(gi.rule,gi.premise1,gi.premise2); ASS_REP(isGeneratingInferenceRule(gi.rule),ruleName(gi.rule)); @@ -474,8 +434,6 @@ Inference::Inference(const GeneratingInference2& gi) { } Inference::Inference(const GeneratingInferenceMany& gi) { - CALL("Inference::Inference(GeneratingInferenceMany)"); - initMany(gi.rule,gi.premises); ASS_REP(isGeneratingInferenceRule(gi.rule),ruleName(gi.rule)); @@ -491,8 +449,6 @@ Inference::Inference(const GeneratingInferenceMany& gi) { } Inference::Inference(const SimplifyingInference1& si) { - CALL("Inference::Inference(SimplifyingInference1)"); - init1(si.rule,si.premise); ASS_REP(isSimplifyingInferenceRule(si.rule),ruleName(si.rule)); @@ -502,8 +458,6 @@ Inference::Inference(const SimplifyingInference1& si) { } Inference::Inference(const SimplifyingInference2& si) { - CALL("Inference::Inference(SimplifyingInference2)"); - init2(si.rule,si.premise1,si.premise2); ASS_REP(isSimplifyingInferenceRule(si.rule),ruleName(si.rule)); @@ -514,8 +468,6 @@ Inference::Inference(const SimplifyingInference2& si) { } Inference::Inference(const SimplifyingInferenceMany& si) { - CALL("Inference::Inference(SimplifyingInferenceMany)"); - initMany(si.rule,si.premises); ASS_REP(isSimplifyingInferenceRule(si.rule),ruleName(si.rule)); @@ -526,33 +478,23 @@ Inference::Inference(const SimplifyingInferenceMany& si) { } Inference::Inference(const NonspecificInference0& gi) { - CALL("Inference::Inference(GenericInference0)"); - init0(gi.inputType,gi.rule); } Inference::Inference(const NonspecificInference1& gi) { - CALL("Inference::Inference(GenericInference1)"); - init1(gi.rule,gi.premise); } Inference::Inference(const NonspecificInference2& gi) { - CALL("Inference::Inference(GenericInference2)"); - init2(gi.rule,gi.premise1,gi.premise2); } Inference::Inference(const NonspecificInferenceMany& gi) { - CALL("Inference::Inference(GenericInferenceMany)"); - initMany(gi.rule,gi.premises); } void Inference::minimizePremises() { - CALL("Inference::minimizePremises"); - if (_kind != Kind::INFERENCE_FROM_SAT_REFUTATION) return; if (_ptr2 == nullptr) @@ -598,8 +540,6 @@ void Inference::minimizePremises() void Inference::computeTheoryRunningSums() { - CALL("Inference::computeTheoryRunningSums"); - Inference::Iterator parentIt = iterator(); // inference without parents @@ -639,8 +579,6 @@ void Inference::computeTheoryRunningSums() */ vstring Kernel::ruleName(InferenceRule rule) { - CALL("Kernel::ruleName"); - switch (rule) { case InferenceRule::INPUT: return "input"; diff --git a/Kernel/Inference.hpp b/Kernel/Inference.hpp index e7e113531..34b293dd3 100644 --- a/Kernel/Inference.hpp +++ b/Kernel/Inference.hpp @@ -718,8 +718,6 @@ class Inference }; void initDefault(UnitInputType inputType, InferenceRule r) { - CALL("Inference::initDefault"); - _inputType = inputType; _rule = r; _included = false; diff --git a/Kernel/InferenceStore.cpp b/Kernel/InferenceStore.cpp index dbd49c876..f7f01d43e 100644 --- a/Kernel/InferenceStore.cpp +++ b/Kernel/InferenceStore.cpp @@ -55,8 +55,6 @@ using namespace Shell; void InferenceStore::FullInference::increasePremiseRefCounters() { - CALL("InferenceStore::FullInference::increasePremiseRefCounters"); - for(unsigned i=0;iisClause()) { premises[i]->incRefCnt(); @@ -72,8 +70,6 @@ InferenceStore::InferenceStore() vstring InferenceStore::getUnitIdStr(Unit* cs) { - CALL("InferenceStore::getUnitIdStr"); - if (!cs->isClause()) { return Int::toString(cs->number()); } @@ -85,8 +81,6 @@ vstring InferenceStore::getUnitIdStr(Unit* cs) */ void InferenceStore::recordSplittingNameLiteral(Unit* us, Literal* lit) { - CALL("InferenceStore::recordSplittingNameLiteral"); - //each clause is result of a splitting only once ALWAYS(_splittingNameLiterals.insert(us, lit)); } @@ -97,8 +91,6 @@ void InferenceStore::recordSplittingNameLiteral(Unit* us, Literal* lit) */ void InferenceStore::recordIntroducedSymbol(Unit* u, SymbolType st, unsigned number) { - CALL("InferenceStore::recordIntroducedSymbol"); - SymbolStack* pStack; _introducedSymbols.getValuePtr(u->number(),pStack); pStack->push(SymbolId(st,number)); @@ -109,7 +101,6 @@ void InferenceStore::recordIntroducedSymbol(Unit* u, SymbolType st, unsigned num */ void InferenceStore::recordIntroducedSplitName(Unit* u, vstring name) { - CALL("InferenceStore::recordIntroducedSplitName"); ALWAYS(_introducedSplitNames.insert(u->number(),name)); } @@ -121,7 +112,6 @@ void InferenceStore::recordIntroducedSplitName(Unit* u, vstring name) */ UnitIterator InferenceStore::getParents(Unit* us, InferenceRule& rule) { - CALL("InferenceStore::getParents/2"); ASS_NEQ(us,0); // The unit itself stores the inference @@ -148,8 +138,6 @@ UnitIterator InferenceStore::getParents(Unit* us, InferenceRule& rule) */ UnitIterator InferenceStore::getParents(Unit* us) { - CALL("InferenceStore::getParents/1"); - InferenceRule aux; return getParents(us, aux); } @@ -161,8 +149,6 @@ UnitIterator InferenceStore::getParents(Unit* us) */ template vstring getQuantifiedStr(const VarContainer& vars, vstring inner, DHMap& t_map, bool innerParentheses=true){ - CALL("getQuantifiedStr(VarContainer, vstring, map)"); - VirtualIterator vit=pvi( getContentIterator(vars) ); vstring varStr; bool first=true; @@ -207,7 +193,6 @@ vstring getQuantifiedStr(const VarContainer& vars, vstring inner, DHMap vstring getQuantifiedStr(const VarContainer& vars, vstring inner, bool innerParentheses=true) { - CALL("getQuantifiedStr(VarContainer, vstring)"); static DHMap d; return getQuantifiedStr(vars,inner,d,innerParentheses); } @@ -217,8 +202,6 @@ vstring getQuantifiedStr(const VarContainer& vars, vstring inner, bool innerPare */ vstring getQuantifiedStr(Unit* u, List* nonQuantified=0) { - CALL("getQuantifiedStr(Unit*...)"); - Set vars; vstring res; DHMap t_map; @@ -269,16 +252,12 @@ struct InferenceStore::ProofPrinter ProofPrinter(ostream& out, InferenceStore* is) : _is(is), out(out) { - CALL("InferenceStore::ProofPrinter::ProofPrinter"); - outputAxiomNames=env.options->outputAxiomNames(); delayPrinting=true; } void scheduleForPrinting(Unit* us) { - CALL("InferenceStore::ProofPrinter::scheduleForPrinting"); - outKernel.push(us); handledKernel.insert(us); } @@ -287,8 +266,6 @@ struct InferenceStore::ProofPrinter virtual void print() { - CALL("InferenceStore::ProofPrinter::print"); - while(outKernel.isNonEmpty()) { Unit* cs=outKernel.pop(); handleStep(cs); @@ -313,8 +290,6 @@ struct InferenceStore::ProofPrinter virtual void printStep(Unit* cs) { - CALL("InferenceStore::ProofPrinter::printStep"); - InferenceRule rule; UnitIterator parents=_is->getParents(cs, rule); @@ -409,7 +384,6 @@ struct InferenceStore::ProofPrinter void handleStep(Unit* cs) { - CALL("InferenceStore::ProofPrinter::handleStep"); InferenceRule rule; UnitIterator parents=_is->getParents(cs, rule); @@ -427,8 +401,6 @@ struct InferenceStore::ProofPrinter void printDelayed() { - CALL("InferenceStore::ProofPrinter::printDelayed"); - // Sort sort(delayed.begin(),delayed.end()); @@ -460,8 +432,6 @@ struct InferenceStore::ProofPropertyPrinter ProofPropertyPrinter(ostream& out, InferenceStore* is) : ProofPrinter(out,is) { - CALL("InferenceStore::ProofPropertyPrinter::ProofPropertyPrinter"); - max_theory_clause_depth = 0; for(unsigned i=0;i<11;i++){ buckets.push(0); } last_one = false; @@ -603,7 +573,6 @@ struct InferenceStore::TPTPProofPrinter vstring splitsToString(SplitSet* splits) { - CALL("InferenceStore::TPTPProofPrinter::splitsToString"); ASS_G(splits->size(),0); if (splits->size()==1) { @@ -623,8 +592,6 @@ struct InferenceStore::TPTPProofPrinter vstring quoteAxiomName(vstring n) { - CALL("InferenceStore::TPTPProofPrinter::quoteAxiomName"); - static vstring allowedFirst("0123456789abcdefghijklmnopqrstuvwxyz"); const char* allowed="_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz"; @@ -637,8 +604,6 @@ struct InferenceStore::TPTPProofPrinter vstring getFofString(vstring id, vstring formula, vstring inference, InferenceRule rule, UnitInputType origin=UnitInputType::AXIOM) { - CALL("InferenceStore::TPTPProofPrinter::getFofString"); - vstring kind = "fof"; if(env.getMainProblem()->hasNonDefaultSorts()){ kind="tff"; } if(env.getMainProblem()->isHigherOrder()){ kind="thf"; } @@ -650,8 +615,6 @@ struct InferenceStore::TPTPProofPrinter vstring getFormulaString(Unit* us) { - CALL("InferenceStore::TPTPProofPrinter::getFormulaString"); - vstring formulaStr; if (us->isClause()) { Clause* cl=us->asClause(); @@ -668,7 +631,6 @@ struct InferenceStore::TPTPProofPrinter } bool hasNewSymbols(Unit* u) { - CALL("InferenceStore::TPTPProofPrinter::hasNewSymbols"); bool res = _is->_introducedSymbols.find(u->number()); ASS(!res || _is->_introducedSymbols.get(u->number()).isNonEmpty()); if(!res){ @@ -677,14 +639,11 @@ struct InferenceStore::TPTPProofPrinter return res; } vstring getNewSymbols(vstring origin, vstring symStr) { - CALL("InferenceStore::TPTPProofPrinter::getNewSymbols(vstring,vstring)"); return "new_symbols(" + origin + ",[" +symStr + "])"; } /** It is an iterator over SymbolId */ template vstring getNewSymbols(vstring origin, It symIt) { - CALL("InferenceStore::TPTPProofPrinter::getNewSymbols(vstring,It)"); - vostringstream symsStr; while(symIt.hasNext()) { SymbolId sym = symIt.next(); @@ -702,7 +661,6 @@ struct InferenceStore::TPTPProofPrinter return getNewSymbols(origin, symsStr.str()); } vstring getNewSymbols(vstring origin, Unit* u) { - CALL("InferenceStore::TPTPProofPrinter::getNewSymbols(vstring,Unit*)"); ASS(hasNewSymbols(u)); if(_is->_introducedSplitNames.find(u->number())){ @@ -715,8 +673,6 @@ struct InferenceStore::TPTPProofPrinter void printStep(Unit* us) { - CALL("InferenceStore::TPTPProofPrinter::printStep"); - InferenceRule rule; UnitIterator parents=_is->getParents(us, rule); @@ -789,7 +745,6 @@ struct InferenceStore::TPTPProofPrinter void printSplitting(Unit* us) { - CALL("InferenceStore::TPTPProofPrinter::printSplitting"); ASS(us->isClause()); InferenceRule rule; @@ -818,7 +773,6 @@ struct InferenceStore::TPTPProofPrinter void printGeneralSplittingComponent(Unit* us) { - CALL("InferenceStore::TPTPProofPrinter::printGeneralSplittingComponent"); ASS(us->isClause()); InferenceRule rule; @@ -888,7 +842,6 @@ struct InferenceStore::TPTPProofPrinter void printSplittingComponentIntroduction(Unit* us) { - CALL("InferenceStore::TPTPProofPrinter::printSplittingComponentIntroduction"); ASS(us->isClause()); Clause* cl=us->asClause(); @@ -926,7 +879,6 @@ struct InferenceStore::ProofCheckPrinter protected: void printStep(Unit* cs) { - CALL("InferenceStore::ProofCheckPrinter::printStep"); InferenceRule rule; UnitIterator parents=_is->getParents(cs, rule); @@ -998,8 +950,6 @@ struct InferenceStore::ProofCheckPrinter InferenceStore::ProofPrinter* InferenceStore::createProofPrinter(ostream& out) { - CALL("InferenceStore::createProofPrinter"); - switch(env.options->proof()) { case Options::Proof::ON: return new ProofPrinter(out, this); @@ -1023,8 +973,6 @@ InferenceStore::ProofPrinter* InferenceStore::createProofPrinter(ostream& out) */ void InferenceStore::outputUnsatCore(ostream& out, Unit* refutation) { - CALL("InferenceStore::outputUnsatCore(ostream&,Unit*)"); - out << "(" << endl; Stack todo; @@ -1080,8 +1028,6 @@ void InferenceStore::outputUnsatCore(ostream& out, Unit* refutation) */ void InferenceStore::outputProof(ostream& out, Unit* refutation) { - CALL("InferenceStore::outputProof(ostream&,Unit*)"); - ProofPrinter* p = createProofPrinter(out); if (!p) { return; @@ -1097,8 +1043,6 @@ void InferenceStore::outputProof(ostream& out, Unit* refutation) */ void InferenceStore::outputProof(ostream& out, UnitList* units) { - CALL("InferenceStore::outputProof(ostream&,UnitList*)"); - ProofPrinter* p = createProofPrinter(out); if (!p) { return; diff --git a/Kernel/InterpretedLiteralEvaluator.cpp b/Kernel/InterpretedLiteralEvaluator.cpp index 38d08a5f0..18c1cd1c0 100644 --- a/Kernel/InterpretedLiteralEvaluator.cpp +++ b/Kernel/InterpretedLiteralEvaluator.cpp @@ -22,7 +22,6 @@ #include "Term.hpp" #include "Theory.hpp" #include "NumTraits.hpp" -#include "Debug/Tracer.hpp" #include "InterpretedLiteralEvaluator.hpp" @@ -142,7 +141,6 @@ CLASS_NAME(InterpretedLiteralEvaluator::ACFunEvaluator); virtual bool canEvaluateFunc(unsigned func) { return func == _fun; } virtual bool tryEvaluateFunc(Term* trm, TermList& res) { - CALL( "ACFunEvaluator::tryEvaluateFunc()" ); ASS_EQ(trm->functor(), _fun); ASS_EQ(trm->numTermArguments(),2); @@ -192,7 +190,6 @@ class InequalityNormalizer { public: static Literal* normalize(Literal* in) { - CALL("IntLess::normalize"); ASS(in->functor() == Inequality::functor()); if (Inequality::isNormalized(in)) { @@ -280,7 +277,6 @@ class InterpretedLiteralEvaluator::EqualityEvaluator template bool checkEquality(Literal* lit, bool& res) { - CALL("InterpretedLiteralEvaluator::EqualityEvaluator::checkEquality"); T arg1; if(!theory->tryInterpretConstant(lit->termArg(0).term(),arg1)){ return false; @@ -326,8 +322,6 @@ class InterpretedLiteralEvaluator::ConversionEvaluator public: bool canEvaluateFunc(unsigned func) override { - CALL("InterpretedLiteralEvaluator::ConversionEvaluator::canEvaluateFunc"); - if (!theory->isInterpretedFunction(func)) { return false; } @@ -336,7 +330,6 @@ class InterpretedLiteralEvaluator::ConversionEvaluator virtual bool tryEvaluateFunc(Term* trm, TermList& res) override { - CALL("InterpretedLiteralEvaluator::ConversionEvaluator::tryEvaluateFunc"); ASS(theory->isInterpretedFunction(trm)); try { @@ -446,8 +439,6 @@ class InterpretedLiteralEvaluator::TypedEvaluator : public Evaluator virtual bool canEvaluate(Interpretation interp) { - CALL("InterpretedLiteralEvaluator::TypedEvaluator::canEvaluate"); - // This is why we cannot evaluate Equality here... we cannot determine its sort if (!theory->hasSingleSort(interp)) { return false; } //To skip conversions and EQUAL @@ -459,7 +450,6 @@ class InterpretedLiteralEvaluator::TypedEvaluator : public Evaluator virtual bool tryEvaluateFunc(Term* trm, TermList& res) override { - CALL("InterpretedLiteralEvaluator::tryEvaluateFunc"); ASS(theory->isInterpretedFunction(trm)); const auto num = NumTraits{}; @@ -558,7 +548,6 @@ class InterpretedLiteralEvaluator::TypedEvaluator : public Evaluator virtual PredEvalResult tryEvaluatePred(Literal* lit) override { - CALL("InterpretedLiteralEvaluator::tryEvaluatePred"); ASS(theory->isInterpretedPredicate(lit->functor())); bool res; @@ -596,8 +585,6 @@ class InterpretedLiteralEvaluator::TypedEvaluator : public Evaluator bool canEvaluateFunc(unsigned func) override { - CALL("InterpretedLiteralEvaluator::TypedEvaluator::canEvaluateFunc"); - if (!theory->isInterpretedFunction(func)) { return false; } @@ -607,8 +594,6 @@ class InterpretedLiteralEvaluator::TypedEvaluator : public Evaluator bool canEvaluatePred(unsigned pred) override { - CALL("InterpretedLiteralEvaluator::TypedEvaluator::canEvaluatePred"); - if (!theory->isInterpretedPredicate(pred)) { return false; } @@ -702,8 +687,6 @@ class InterpretedLiteralEvaluator::IntEvaluator : public TypedEvaluatorarg2; @@ -809,8 +788,6 @@ class InterpretedLiteralEvaluator::RatEvaluator : public TypedEvaluatorarg2; @@ -879,8 +852,6 @@ class InterpretedLiteralEvaluator::RatEvaluator : public TypedEvaluatorarg2; @@ -976,8 +941,6 @@ class InterpretedLiteralEvaluator::RealEvaluator : public TypedEvaluator& sideConditions) { - CALL("InterpretedLiteralEvaluator::balance"); ASS(balancable(lit)); _DEBUG( "try balance ", lit->toString() ); @@ -1268,8 +1225,6 @@ bool InterpretedLiteralEvaluator::balance(Literal* lit,Literal*& resLit,Stack
  • getInterpretingSymbol(unaryMinus); unsigned ip = env.signature->getInterpretingSymbol(plus); TermList B; @@ -1291,7 +1246,6 @@ bool InterpretedLiteralEvaluator::balanceMultiply(Interpretation divide,Constant Term* AmultiplyB, TermList A, TermList C, TermList& result, bool& swap, Stack& sideConditions) { - CALL("InterpretedLiteralEvaluator::balanceMultiply"); #if VDEBUG TermList srt = theory->getOperationSort(divide); ASS(srt == AtomicSort::realSort() || srt == AtomicSort::rationalSort()); @@ -1329,8 +1283,6 @@ bool InterpretedLiteralEvaluator::balanceIntegerMultiply( Term* AmultiplyB, TermList A, TermList C, TermList& result, bool& swap, Stack& sideConditions) { - CALL("InterpretedLiteralEvaluator::balanceIntegerMultiply"); - // only works if we in the end divid a number by a number IntegerConstantType ccon; if(!theory->tryInterpretConstant(C,ccon)){ return false; } @@ -1360,7 +1312,6 @@ bool InterpretedLiteralEvaluator::balanceIntegerMultiply( bool InterpretedLiteralEvaluator::balanceDivide(Interpretation multiply, Term* AoverB, TermList A, TermList C, TermList& result, bool& swap, Stack& sideConditions) { - CALL("InterpretedLiteralEvaluator::balanceDivide"); #if VDEBUG TermList srt = theory->getOperationSort(multiply); ASS(srt == AtomicSort::realSort() || srt == AtomicSort::rationalSort()); @@ -1429,7 +1380,6 @@ class LiteralNormalizer public: static Literal* normalize(Literal* in) { - CALL("LiteralNormalizer::normalize"); auto functor = in->functor(); if (theory->isInterpretedPredicate(functor)) { @@ -1455,7 +1405,6 @@ class LiteralNormalizer } }; TermList InterpretedLiteralEvaluator::evaluate(TermList t) { - CALL("InterpretedLiteralEvaluator::evaluate") if (t.isTerm()) t = TermList(BottomUpTermTransformer::transform(t.term())); return InterpretedLiteralEvaluator::transformSubterm(t); @@ -1470,8 +1419,6 @@ TermList InterpretedLiteralEvaluator::evaluate(TermList t) { */ bool InterpretedLiteralEvaluator::evaluate(Literal* lit, bool& isConstant, Literal*& resLit, bool& resConst,Stack& sideConditions) { - CALL("InterpretedLiteralEvaluator::evaluate"); - DEBUG( "evaluate ", lit->toString() ); // This tries to transform each subterm using tryEvaluateFunc (see transform Subterm below) @@ -1559,7 +1506,6 @@ bool InterpretedLiteralEvaluator::evaluate(Literal* lit, bool& isConstant, Liter */ TermList InterpretedLiteralEvaluator::transformSubterm(TermList trm) { - CALL("InterpretedLiteralEvaluator::transformSubterm"); // Debug::Tracer::printStack(cout); // DEBUG( "transformSubterm for ", trm.toString() ); @@ -1587,8 +1533,6 @@ TermList InterpretedLiteralEvaluator::transformSubterm(TermList trm) template InterpretedLiteralEvaluator::Evaluator* InterpretedLiteralEvaluator::getEvaluator(unsigned functor, DArray& evaluators, Fn canEval) { - CALL("InterpretedLiteralEvaluator::getEvaluator"); - if (functor >= evaluators.size()) { unsigned oldSz = evaluators.size(); unsigned newSz = functor + 1 ; @@ -1614,7 +1558,6 @@ break_inner:; */ InterpretedLiteralEvaluator::Evaluator* InterpretedLiteralEvaluator::getFuncEvaluator(unsigned func) { - CALL("InterpretedLiteralEvaluator::getFuncEvaluator"); return getEvaluator(func, this->_funEvaluators, [] (Evaluator* ev, unsigned i) {return ev->canEvaluateFunc(i); }); @@ -1625,7 +1568,6 @@ InterpretedLiteralEvaluator::Evaluator* InterpretedLiteralEvaluator::getFuncEval */ InterpretedLiteralEvaluator::Evaluator* InterpretedLiteralEvaluator::getPredEvaluator(unsigned pred) { - CALL("InterpretedLiteralEvaluator::getPredEvaluator"); return getEvaluator(pred, this->_predEvaluators, [] (Evaluator* ev, unsigned i) {return ev->canEvaluatePred(i); }); } diff --git a/Kernel/KBO.cpp b/Kernel/KBO.cpp index 5c5a2d112..20cc2777e 100644 --- a/Kernel/KBO.cpp +++ b/Kernel/KBO.cpp @@ -14,7 +14,6 @@ * @since 30/04/2008 flight Brussels-Tel Aviv */ -#include "Debug/Tracer.hpp" #include "Kernel/NumTraits.hpp" #include "Lib/Environment.hpp" @@ -98,7 +97,6 @@ class KBO::State */ Ordering::Result KBO::State::result(Term* t1, Term* t2) { - CALL("KBO::State::result") Result res; if(_weightDiff) { res=_weightDiff>0 ? GREATER : LESS; @@ -136,8 +134,6 @@ Ordering::Result KBO::State::result(Term* t1, Term* t2) Ordering::Result KBO::State::innerResult(TermList tl1, TermList tl2) { - CALL("KBO::State::innerResult"); - ASS_NEQ(tl1, tl2); ASS(!TermList::sameTopFunctor(tl1,tl2)); @@ -168,7 +164,6 @@ Ordering::Result KBO::State::innerResult(TermList tl1, TermList tl2) void KBO::State::recordVariable(unsigned var, int coef) { - CALL("KBO::State::recordVariable"); ASS(coef==1 || coef==-1); int* pnum; @@ -191,8 +186,6 @@ void KBO::State::recordVariable(unsigned var, int coef) void KBO::State::traverse(TermList tl,int coef) { - CALL("KBO::State::traverse(TermList...)"); - if(tl.isOrdinaryVar()) { _weightDiff += _kbo._funcWeights._specialWeights._variableWeight * coef; recordVariable(tl.var(), coef); @@ -236,7 +229,6 @@ void KBO::State::traverse(TermList tl,int coef) void KBO::State::traverse(Term* t1, Term* t2) { - CALL("KBO::State::traverse"); ASS(t1->functor()==t2->functor()); ASS(t1->arity()); ASS_EQ(_lexResult, EQUAL); @@ -562,7 +554,6 @@ KBO KBO::testKBO() } void KBO::zeroWeightForMaximalFunc() { - CALL("KBO::zeroWeightForMaximalFunc"); // actually, it's non-constant maximal func, as constants cannot be weight 0 using FunctionSymbol = unsigned; @@ -652,8 +643,6 @@ KBO::KBO(Problem& prb, const Options& opts) #endif , _state(new State(this)) { - CALL("KBO::KBO(Prb&, Opts&)"); - if (opts.kboMaxZero()) { zeroWeightForMaximalFunc(); } @@ -666,8 +655,6 @@ KBO::KBO(Problem& prb, const Options& opts) KBO::~KBO() { - CALL("KBO::~KBO"); - delete _state; } @@ -678,7 +665,6 @@ KBO::~KBO() */ Ordering::Result KBO::comparePredicates(Literal* l1, Literal* l2) const { - CALL("KBO::comparePredicates"); ASS(l1->shared()); ASS(l2->shared()); ASS(!l1->isEquality()); @@ -720,8 +706,6 @@ Ordering::Result KBO::comparePredicates(Literal* l1, Literal* l2) const Ordering::Result KBO::compare(TermList tl1, TermList tl2) const { - CALL("KBO::compare(TermList)"); - if(tl1==tl2) { return EQUAL; } diff --git a/Kernel/KBOForEPR.cpp b/Kernel/KBOForEPR.cpp index bb093844f..83637f84a 100644 --- a/Kernel/KBOForEPR.cpp +++ b/Kernel/KBOForEPR.cpp @@ -12,7 +12,6 @@ * Implements class KBOForEPR for instances of the Knuth-Bendix ordering for EPR problems */ -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" @@ -42,7 +41,6 @@ using namespace Lib; KBOForEPR::KBOForEPR(Problem& prb, const Options& opt) : PrecedenceOrdering(prb, opt) { - CALL("KBOForEPR::KBOForEPR"); ASS_EQ(prb.getProperty()->maxFunArity(),0); } @@ -53,7 +51,6 @@ KBOForEPR::KBOForEPR(Problem& prb, const Options& opt) */ Ordering::Result KBOForEPR::comparePredicates(Literal* l1, Literal* l2) const { - CALL("KBOForEPR::comparePredicates(Literal*...)"); ASS(l1->shared()); ASS(l2->shared()); ASS(!l1->isEquality()); @@ -90,7 +87,6 @@ Ordering::Result KBOForEPR::comparePredicates(Literal* l1, Literal* l2) const Ordering::Result KBOForEPR::compare(TermList tl1, TermList tl2) const { - CALL("KBOForEPR::compare(TermList)"); ASS(!tl1.isTerm() || tl1.term()->arity()==0) ASS(!tl2.isTerm() || tl2.term()->arity()==0) diff --git a/Kernel/LPO.cpp b/Kernel/LPO.cpp index c2ac7e3c4..a1c2c7040 100644 --- a/Kernel/LPO.cpp +++ b/Kernel/LPO.cpp @@ -15,7 +15,6 @@ * Redundancy Avoidance" Section 4.2 */ -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" @@ -38,7 +37,6 @@ using namespace Shell; */ Ordering::Result LPO::comparePredicates(Literal* l1, Literal *l2) const { - CALL("LPO::comparePredicates"); ASS(l1->shared()); ASS(l2->shared()); ASS(!l1->isEquality()); @@ -66,7 +64,6 @@ Ordering::Result LPO::comparePredicates(Literal* l1, Literal *l2) const Ordering::Result LPO::comparePrecedences(Term* t1, Term* t2) const { - CALL("LPO::comparePrecedences"); if (t1->isSort() && t2->isSort()) { return compareTypeConPrecedences(t1->functor(), t2->functor()); } @@ -82,8 +79,6 @@ Ordering::Result LPO::comparePrecedences(Term* t1, Term* t2) const Ordering::Result LPO::compare(TermList tl1, TermList tl2) const { - CALL("LPO::compare(TermList, TermList)"); - if(tl1==tl2) { return EQUAL; } @@ -96,7 +91,6 @@ Ordering::Result LPO::compare(TermList tl1, TermList tl2) const Ordering::Result LPO::clpo(Term* t1, TermList tl2) const { - CALL("LPO::clpo"); ASS(t1->shared()); if(tl2.isOrdinaryVar()) { @@ -128,8 +122,6 @@ Ordering::Result LPO::clpo(Term* t1, TermList tl2) const */ Ordering::Result LPO::cMA(Term *s, TermList* tl, unsigned arity) const { - CALL("LPO::cMA"); - ASS(s->shared()); for (unsigned i = 0; i < arity; i++) { @@ -150,7 +142,6 @@ Ordering::Result LPO::cMA(Term *s, TermList* tl, unsigned arity) const Ordering::Result LPO::cLMA(Term* s, Term* t, TermList* sl, TermList* tl, unsigned arity) const { - CALL("LPO::cLMA"); ASS(s->shared()); ASS(t->shared()); @@ -173,7 +164,6 @@ Ordering::Result LPO::cLMA(Term* s, Term* t, TermList* sl, TermList* tl, unsigne Ordering::Result LPO::cAA(Term* s, Term* t, TermList* sl, TermList* tl, unsigned arity1, unsigned arity2) const { - CALL("LPO::cAA"); ASS(s->shared()); ASS(t->shared()); @@ -190,7 +180,6 @@ Ordering::Result LPO::cAA(Term* s, Term* t, TermList* sl, TermList* tl, unsigned // greater iff some exists s_i in sl such that s_i >= t Ordering::Result LPO::alpha(TermList* sl, unsigned arity, Term *t) const { - CALL("LPO::alpha"); ASS(t->shared()); for (unsigned i = 0; i < arity; i++) { @@ -212,8 +201,6 @@ Ordering::Result LPO::alpha(TermList* sl, unsigned arity, Term *t) const // tl2 or tl1 = tl2) Ordering::Result LPO::lpo(TermList tl1, TermList tl2) const { - CALL("LPO::lpo(TermList, TermList)"); - if(tl1==tl2) { return EQUAL; } @@ -243,8 +230,6 @@ Ordering::Result LPO::lpo(TermList tl1, TermList tl2) const Ordering::Result LPO::lexMAE(Term* s, Term* t, TermList* sl, TermList* tl, unsigned arity) const { - CALL("LPO::lexMAE"); - ASS(s->shared()); ASS(t->shared()); @@ -268,8 +253,6 @@ Ordering::Result LPO::lexMAE(Term* s, Term* t, TermList* sl, TermList* tl, unsig // greater if s is greater than every term in tl Ordering::Result LPO::majo(Term* s, TermList* tl, unsigned arity) const { - CALL("LPO::majo"); - ASS(s->shared()); for (unsigned i = 0; i < arity; i++) { diff --git a/Kernel/LiteralComparators.hpp b/Kernel/LiteralComparators.hpp index d9412724f..79cfbdf2f 100644 --- a/Kernel/LiteralComparators.hpp +++ b/Kernel/LiteralComparators.hpp @@ -40,8 +40,6 @@ class LiteralComparator virtual void attachSelector(LiteralSelector* selector) { - CALL("LiteralComparator::attachSelector"); - _selector = selector; } protected: @@ -60,8 +58,6 @@ class Composite : public LiteralComparator virtual void attachSelector(LiteralSelector* selector) { - CALL("LiteralComparators::Composite::attachSelector"); - LiteralComparator::attachSelector(selector); _c1.attachSelector(selector); _c2.attachSelector(selector); @@ -82,8 +78,6 @@ class Inverse : public LiteralComparator virtual void attachSelector(LiteralSelector* selector) { - CALL("LiteralComparators::Inverse::attachSelector"); - LiteralComparator::attachSelector(selector); _c.attachSelector(selector); } @@ -109,8 +103,6 @@ struct NoPositiveEquality : public LiteralComparator { Comparison compare(Literal* l1, Literal* l2) { - CALL("LiteralComparators::NoPositiveEquality::compare"); - bool l1PE=l1->isEquality()&&l1->isPositive(); bool l2PE=l2->isEquality()&&l2->isPositive(); if( l1PE && !l2PE ) { @@ -127,7 +119,6 @@ struct Negative : public LiteralComparator { Comparison compare(Literal* l1, Literal* l2) { - CALL("LiteralComparators::Negative::compare"); ASS(_selector); bool l1N=_selector->isNegativeForSelection(l1); diff --git a/Kernel/LiteralSelector.cpp b/Kernel/LiteralSelector.cpp index a288d5360..829c06337 100644 --- a/Kernel/LiteralSelector.cpp +++ b/Kernel/LiteralSelector.cpp @@ -61,8 +61,6 @@ bool LiteralSelector::isPositiveForSelection(Literal* l) const */ int LiteralSelector::getSelectionPriority(Literal* l) const { - CALL("LiteralSelector::getSelectionPriority"); - Signature::Symbol* psym=env.signature->getPredicate(l->functor()); if(psym->label() || psym->answerPredicate()) { return -2; @@ -81,8 +79,6 @@ int LiteralSelector::getSelectionPriority(Literal* l) const */ LiteralSelector* LiteralSelector::getSelector(const Ordering& ordering, const Options& options, int selectorNumber) { - CALL("LiteralSelector::getSelector"); - using namespace LiteralComparators; typedef Compositecolor()==COLOR_TRANSPARENT) { //if no literal is colored, do nothing return; @@ -194,7 +188,6 @@ void LiteralSelector::ensureSomeColoredSelected(Clause* c, unsigned eligible) */ void LiteralSelector::select(Clause* c, unsigned eligibleInp) { - CALL("LiteralSelector::select"); ASS_LE(eligibleInp, c->length()); if(eligibleInp==0) { @@ -244,8 +237,6 @@ void LiteralSelector::select(Clause* c, unsigned eligibleInp) */ void TotalLiteralSelector::doSelection(Clause* c, unsigned eligible) { - CALL("TotalLiteralSelector::doSelection"); - c->setSelected(eligible); } diff --git a/Kernel/LookaheadLiteralSelector.cpp b/Kernel/LookaheadLiteralSelector.cpp index 9d0ac4dd7..253b07d26 100644 --- a/Kernel/LookaheadLiteralSelector.cpp +++ b/Kernel/LookaheadLiteralSelector.cpp @@ -51,8 +51,6 @@ struct LookaheadLiteralSelector::GenIteratorIterator bool hasNext() { - CALL("LookaheadLiteralSelector::GenIteratorIterator::hasNext"); - if(prepared) { return true; } @@ -136,7 +134,6 @@ struct LookaheadLiteralSelector::GenIteratorIterator VirtualIterator next() { - CALL("LookaheadLiteralSelector::GenIteratorIterator::next"); if(!prepared) { ALWAYS(hasNext()); } @@ -172,8 +169,6 @@ struct LookaheadLiteralSelector::GenIteratorIterator */ VirtualIterator LookaheadLiteralSelector::getGeneraingInferenceIterator(Literal* lit) { - CALL("LookaheadLiteralSelector::getGeneraingInferenceIterator"); - return pvi( getFlattenedIterator(GenIteratorIterator(lit, *this)) ); } @@ -184,7 +179,6 @@ VirtualIterator LookaheadLiteralSelector::getGeneraingInferenceIterator(Li */ Literal* LookaheadLiteralSelector::pickTheBest(Literal** lits, unsigned cnt) { - CALL("LookaheadLiteralSelector::pickTheBest"); ASS_G(cnt,1); //special cases are handled elsewhere static DArray > runifs; //resolution unification iterators @@ -235,8 +229,6 @@ Literal* LookaheadLiteralSelector::pickTheBest(Literal** lits, unsigned cnt) */ void LookaheadLiteralSelector::removeVariants(LiteralStack& lits) { - CALL("LookaheadLiteralSelector::removeVariants"); - size_t cnt=lits.size(); for(size_t i=0;iselect(c,eligible); diff --git a/Kernel/MLMatcher.cpp b/Kernel/MLMatcher.cpp index ca6246bc9..a7cb486b0 100644 --- a/Kernel/MLMatcher.cpp +++ b/Kernel/MLMatcher.cpp @@ -67,8 +67,6 @@ struct ArrayStoringBinder bool createLiteralBindings(Literal* baseLit, LiteralList const* alts, Clause* instCl, Literal* resolvedLit, unsigned*& boundVarData, TermList**& altBindingPtrs, TermList*& altBindingData) { - CALL("createLiteralBindings"); - static UUMap variablePositions; static BinaryHeap varNums; variablePositions.reset(); @@ -220,8 +218,6 @@ struct MatchingData { bool compatible(unsigned b1Index, TermList* i1Bindings, unsigned b2Index, unsigned i2AltIndex, pair* iinfo) const { - CALL("MatchingData::compatible"); - TermList* i2Bindings=altBindings[b2Index][i2AltIndex]; while(iinfo->first!=-1) { @@ -235,8 +231,6 @@ struct MatchingData { bool bindAlt(unsigned bIndex, unsigned altIndex) { - CALL("MatchingData::bindAlt"); - TermList* curBindings=altBindings[bIndex][altIndex]; for(unsigned i=bIndex+1; i* getIntersectInfo(unsigned b1, unsigned b2) { - CALL("MatchingData::getIntersectInfo"); - ASS_L(b1, b2); pair* res=intersections->get(b2,b1); if( res ) { @@ -311,8 +303,6 @@ struct MatchingData { InitResult ensureInit(unsigned bIndex) { - CALL("MatchingData::ensureInit"); - if(!isInitialized(bIndex)) { boundVarNums[bIndex]=boundVarNumStorage; altBindings[bIndex]=altBindingPtrStorage; @@ -432,8 +422,6 @@ MLMatcher::Impl::Impl() void MLMatcher::Impl::initMatchingData(Literal** baseLits0, unsigned baseLen, Clause* instance, LiteralList const* const* alts, Literal* resolvedLit) { - CALL("MLMatcher::Impl::initMatchingData"); - s_baseLits.initFromArray(baseLen,baseLits0); s_altsArr.initFromArray(baseLen,alts); @@ -544,8 +532,6 @@ void MLMatcher::Impl::initMatchingData(Literal** baseLits0, unsigned baseLen, Cl void MLMatcher::Impl::init(Literal** baseLits, unsigned baseLen, Clause* instance, LiteralList const* const* alts, Literal* resolvedLit, bool multiset) { - CALL("MLMatcher::Impl::init"); - if (resolvedLit) { // NOTE(JR): I think using resolvedLit together with multiset does not work since there's only two match records in that case. // However, I was not able to find a concrete error, so maybe I've missed something. @@ -578,7 +564,6 @@ void MLMatcher::Impl::init(Literal** baseLits, unsigned baseLen, Clause* instanc bool MLMatcher::Impl::nextMatch() { - CALL("MLMatcher::Impl::nextMatch"); MatchingData* const md = &s_matchingData; while (true) { diff --git a/Kernel/MLMatcherSD.cpp b/Kernel/MLMatcherSD.cpp index a97f522ac..7f6549765 100644 --- a/Kernel/MLMatcherSD.cpp +++ b/Kernel/MLMatcherSD.cpp @@ -81,8 +81,6 @@ struct ArrayStoringBinder final */ void createLiteralBindings(Literal* baseLit, LiteralList const* const alts, Clause* instCl, unsigned*& boundVarData, TermList**& altBindingPtrs, TermList*& altBindingData) { - CALL("createLiteralBindings"); - static UUMap variablePositions; static BinaryHeap varNums; variablePositions.reset(); @@ -325,7 +323,6 @@ struct MatchingData final { */ pair* getIntersectInfo(unsigned b1, unsigned b2) { - CALL("MatchingData::getIntersectInfo"); ASS(isInitialized(b1)); ASS(isInitialized(b2)); @@ -406,8 +403,6 @@ struct MatchingData final { bool compatible(unsigned b1Index, TermList* i1Bindings, unsigned b2Index, unsigned i2AltIndex) { - CALL("MatchingData::compatible"); - TermList* i2Bindings=altBindings[b2Index][i2AltIndex]; // Iterate over variables common to bases[b1Index] and bases[b2Index]. @@ -434,7 +429,6 @@ struct MatchingData final { */ bool bindAlt(unsigned bIndex, unsigned altIndex) { - CALL("MatchingData::bindAlt"); ASS_EQ(bIndex, currBLit); ASS_NEQ(bIndex, eqLitForDemodulation); @@ -512,7 +506,6 @@ struct MatchingData final { */ bool selectForDemodulation(unsigned bIndex) { - CALL("MatchingData::selectForDemodulation"); ASS_EQ(bIndex, currBLit); ASS(bases[bIndex]->isEquality()); ASS(bases[bIndex]->isPositive()); @@ -559,7 +552,6 @@ struct MatchingData final { */ InitResult ensureInit(unsigned bIndex) { - CALL("MatchingData::ensureInit"); ASS_EQ(bIndex, currBLit); if(!isInitialized(bIndex)) { @@ -772,8 +764,6 @@ MLMatcherSD::Impl::Impl() void MLMatcherSD::Impl::initMatchingData(Literal** baseLits0, unsigned baseLen, Clause* instance, LiteralList const* const* alts) { - CALL("MLMatcherSD::Impl::initMatchingData"); - s_baseLits.initFromArray(baseLen,baseLits0); s_altsArr.initFromArray(baseLen,alts); @@ -887,8 +877,6 @@ void MLMatcherSD::Impl::initMatchingData(Literal** baseLits0, unsigned baseLen, void MLMatcherSD::Impl::init(Literal** baseLits, unsigned baseLen, Clause* instance, LiteralList const* const* alts) { - CALL("MLMatcherSD::Impl::init"); - #if MLMATCHERSD_DEBUG_OUTPUT std::cerr << "\n\n\nMLMatcherSD::init:" << std::endl; for (unsigned i = 0; i < baseLen; ++i) { @@ -908,7 +896,6 @@ void MLMatcherSD::Impl::init(Literal** baseLits, unsigned baseLen, Clause* insta bool MLMatcherSD::Impl::nextMatch() { - CALL("MLMatcherSD::Impl::nextMatch"); MatchingData* const md = &s_matchingData; // General Remarks diff --git a/Kernel/MLVariant.cpp b/Kernel/MLVariant.cpp index 794e9cc66..93fc03a96 100644 --- a/Kernel/MLVariant.cpp +++ b/Kernel/MLVariant.cpp @@ -77,8 +77,6 @@ struct ArrayStoringBinder bool createLiteralBindings(Literal* baseLit, LiteralList* alts, Clause* instCl, unsigned*& boundVarData, unsigned**& altBindingPtrs, unsigned*& altBindingData) { - CALL("createLiteralBindings"); - static UUMap variablePositions; static BinaryHeap varNums; variablePositions.reset(); @@ -196,8 +194,6 @@ struct MatchingData { bool compatible(unsigned b1Index, unsigned* i1Bindings, unsigned b2Index, unsigned i2AltIndex) const { - CALL("MatchingData::compatible"); - if(varCnts[b1Index]==0 || varCnts[b2Index]==0) { return true; } //we'll create inverse binding to check that two variables @@ -272,8 +268,6 @@ struct MatchingData { InitResult ensureInit(unsigned bIndex) { - CALL("MatchingData::ensureInit"); - if(!isInitialized(bIndex)) { boundVarNums[bIndex]=boundVarNumStorage; altBindings[bIndex]=altBindingPtrStorage; @@ -310,8 +304,6 @@ struct MatchingData { MatchingData* getMatchingData(Literal* const * baseLits0, unsigned baseLen, Clause* instance, LiteralList** alts) { - CALL("getMatchingData"); - static DArray baseLits(32); static DArray altsArr(32); baseLits.initFromArray(baseLen,baseLits0); @@ -401,8 +393,6 @@ using namespace MLVariant_AUX; */ bool MLVariant::isVariant(Literal* const * cl1Lits, Clause* cl2, LiteralList** alts) { - CALL("MLVariant::isVariant/3"); - unsigned clen=cl2->length(); MatchingData* md=getMatchingData(cl1Lits, clen, cl2, alts); @@ -473,8 +463,6 @@ bool MLVariant::isVariant(Literal* const * cl1Lits, Clause* cl2, LiteralList** a bool MLVariant::isVariant(Literal* const * cl1Lits, Clause* cl2, bool complementary) { - CALL("MLVariant::isVariant/2"); - bool fail=false; unsigned clen=cl2->length(); static DArray alts(32); diff --git a/Kernel/MainLoop.cpp b/Kernel/MainLoop.cpp index d51acb6bb..57f675ac6 100644 --- a/Kernel/MainLoop.cpp +++ b/Kernel/MainLoop.cpp @@ -41,8 +41,6 @@ using namespace FMB; void MainLoopResult::updateStatistics() { - CALL("MainLoopResult::updateStatistics"); - env.statistics->terminationReason = terminationReason; env.statistics->refutation = refutation; env.statistics->saturatedSet = saturatedSet; @@ -56,7 +54,6 @@ void MainLoopResult::updateStatistics() */ MainLoopResult MainLoop::run() { - CALL("MainLoop::run"); TIME_TRACE("main loop"); try { @@ -89,16 +86,11 @@ MainLoopResult MainLoop::run() */ bool MainLoop::isRefutation(Clause* cl) { - CALL("MainLoop::isRefutation"); - return cl->isEmpty() && cl->noSplits(); } MainLoop* MainLoop::createFromOptions(Problem& prb, const Options& opt) { - CALL("MainLoop::createFromOptions"); - - #if VZ3 bool isComplete = false; // artificially prevent smtForGround from running /* diff --git a/Kernel/MainLoop.hpp b/Kernel/MainLoop.hpp index 5aabac1dc..e54147fac 100644 --- a/Kernel/MainLoop.hpp +++ b/Kernel/MainLoop.hpp @@ -72,7 +72,6 @@ class MainLoop { { RefutationFoundException(Clause* ref) : refutation(ref) { - CALL("MainLoop::RefutationFoundException::RefutationFoundException"); ASS(isRefutation(ref)); } diff --git a/Kernel/Matcher.cpp b/Kernel/Matcher.cpp index dccf5bf97..10c3d56e8 100644 --- a/Kernel/Matcher.cpp +++ b/Kernel/Matcher.cpp @@ -59,8 +59,6 @@ class MapBinderAndApplicator TermList MatchingUtils::getInstanceFromMatch(TermList matchedBase, TermList matchedInstance, TermList resultBase) { - CALL("MatchingUtils::getInstanceFromMatch(TermList...)"); - using namespace __MU_Aux; static MapBinderAndApplicator bap; @@ -73,8 +71,6 @@ TermList MatchingUtils::getInstanceFromMatch(TermList matchedBase, Formula* MatchingUtils::getInstanceFromMatch(Literal* matchedBase, Literal* matchedInstance, Formula* resultBase) { - CALL("MatchingUtils::getInstanceFromMatch(Literal*...)"); - using namespace __MU_Aux; static MapBinderAndApplicator bap; @@ -86,8 +82,6 @@ Formula* MatchingUtils::getInstanceFromMatch(Literal* matchedBase, bool MatchingUtils::isVariant(Literal* l1, Literal* l2, bool complementary) { - CALL("MatchingUtils::isVariant"); - if(l1->isTwoVarEquality() && l2->isTwoVarEquality()){ TermList s1 = l1->twoVarEqSort(); TermList s2 = l2->twoVarEqSort(); @@ -116,8 +110,6 @@ bool MatchingUtils::isVariant(Literal* l1, Literal* l2, bool complementary) bool MatchingUtils::haveReversedVariantArgs(Term* l1, Term* l2) { - CALL("MatchingUtils::haveReversedVariantArgs"); - ASS_EQ(l1->arity(), 2); ASS_EQ(l2->arity(), 2); @@ -170,7 +162,6 @@ bool MatchingUtils::haveReversedVariantArgs(Term* l1, Term* l2) bool MatchingUtils::haveVariantArgs(Term* l1, Term* l2) { - CALL("MatchingUtils::haveVariantArgs"); ASS_EQ(l1->arity(), l2->arity()); if(l1==l2) { @@ -206,7 +197,6 @@ bool MatchingUtils::haveVariantArgs(Term* l1, Term* l2) bool MatchingUtils::matchReversedArgs(Literal* base, Literal* instance) { - CALL("MatchingUtils::match"); ASS_EQ(base->arity(), 2); ASS_EQ(instance->arity(), 2); @@ -223,8 +213,6 @@ bool MatchingUtils::matchReversedArgs(Literal* base, Literal* instance) bool MatchingUtils::matchArgs(Term* base, Term* instance) { - CALL("MatchingUtils::matchArgs"); - static MapBinder binder; binder.reset(); @@ -233,8 +221,6 @@ bool MatchingUtils::matchArgs(Term* base, Term* instance) bool MatchingUtils::matchTerms(TermList base, TermList instance) { - CALL("MatchingUtils::matchTerms/2"); - if(base.isTerm()) { if(!instance.isTerm()) { return false; @@ -265,8 +251,6 @@ bool MatchingUtils::matchTerms(TermList base, TermList instance) void OCMatchIterator::init(Literal* base, Literal* inst, bool complementary) { - CALL("FastMatchIterator::init"); - //TODO we don't seem to use this iterator anywhere, so //have not updated to polymorphism if(!Literal::headersMatch(base, inst, complementary)) { @@ -281,8 +265,6 @@ void OCMatchIterator::init(Literal* base, Literal* inst, bool complementary) bool OCMatchIterator::tryNextMatch() { - CALL("FastMatchIterator::tryNextMatch"); - if(_finished) { return false; } @@ -308,16 +290,12 @@ bool OCMatchIterator::tryNextMatch() void OCMatchIterator::reset() { - CALL("FastMatchIterator::reset"); - _bindings.reset(); _bound.reset(); } bool OCMatchIterator::tryDirectMatch() { - CALL("FastMatchIterator::tryDirectMatch"); - bool res=MatchingUtils::matchArgs(_base, _inst, *this); res&=occursCheck(); return res; @@ -325,7 +303,6 @@ bool OCMatchIterator::tryDirectMatch() bool OCMatchIterator::tryReversedMatch() { - CALL("FastMatchIterator::tryReversedMatch"); ASS(_base->commutative()); ASS(_inst->commutative()); @@ -339,8 +316,6 @@ bool OCMatchIterator::tryReversedMatch() bool OCMatchIterator::occursCheck() { - CALL("OCMatchIterator::occursCheck"); - static DHMap statuses; static Stack toDo; statuses.reset(); @@ -411,8 +386,6 @@ bool OCMatchIterator::occursCheck() TermList OCMatchIterator::apply(unsigned var) { - CALL("OCMatchIterator::apply(unsigned)"); - TermList bnd; if(_bindings.find(var, bnd)) { //this may lead to an indirect recursion, but if the occurs check @@ -425,15 +398,11 @@ TermList OCMatchIterator::apply(unsigned var) TermList OCMatchIterator::apply(TermList t) { - CALL("OCMatchIterator::apply(TermList)"); - return SubstHelper::apply(t, *this); } Literal* OCMatchIterator::apply(Literal* lit) { - CALL("OCMatchIterator::apply(Literal*)"); - return SubstHelper::apply(lit, *this); } @@ -460,8 +429,6 @@ class Matcher::CommutativeMatchIterator } bool hasNext() { - CALL("Matcher::CommutativeMatchIterator::hasNext"); - if(_state==FINISHED) { return false; } @@ -541,8 +508,6 @@ struct Matcher::MatchContext : _base(base), _instance(instance) {} bool enter(Matcher* matcher) { - CALL("Matcher::MatchContext::enter"); - matcher->bdRecord(_bdata); bool res=matcher->matchArgs(_base, _instance); if(!res) { @@ -565,8 +530,6 @@ struct Matcher::MatchContext MatchIterator Matcher::matches(Literal* base, Literal* instance, bool complementary) { - CALL("Matcher::matches"); - if(!Literal::headersMatch(base, instance, complementary)) { return MatchIterator::getEmpty(); } @@ -588,8 +551,6 @@ MatchIterator Matcher::matches(Literal* base, Literal* instance, bool Matcher::matchArgs(Literal* base, Literal* instance) { - CALL("Matcher::matchArgs"); - BacktrackData localBD; bdRecord(localBD); @@ -609,7 +570,6 @@ bool Matcher::matchArgs(Literal* base, Literal* instance) bool Matcher::matchReversedArgs(Literal* base, Literal* instance) { - CALL("Matcher::matchReversedArgs"); ASS(base->commutative()); BacktrackData localBD; @@ -633,4 +593,4 @@ bool Matcher::matchReversedArgs(Literal* base, Literal* instance) } -} \ No newline at end of file +} diff --git a/Kernel/Matcher.hpp b/Kernel/Matcher.hpp index ff6d4dac7..65d5432c4 100644 --- a/Kernel/Matcher.hpp +++ b/Kernel/Matcher.hpp @@ -47,8 +47,6 @@ class MatchingUtils static bool match(Literal* base, Literal* instance, bool complementary) { - CALL("MatchingUtils::match"); - static MapBinder binder; return match(base, instance, complementary, binder); } @@ -71,8 +69,6 @@ class MatchingUtils template static bool match(Literal* base, Literal* instance, bool complementary, Binder& binder) { - CALL("MatchingUtils::match(Literal*, Literal*, bool, Binder&)"); - if(!Literal::headersMatch(base,instance,complementary)) { return false; } @@ -102,8 +98,6 @@ class MatchingUtils template static bool matchTerms(TermList base, TermList instance, Binder& binder) { - CALL("MatchingUtils::matchTerms/3"); - if(base.isTerm()) { Term* bt=base.term(); if(!instance.isTerm() || base.term()->functor()!=instance.term()->functor()) { @@ -290,7 +284,6 @@ class Matcher template bool MatchingUtils::matchReversedArgs(Literal* base, Literal* instance, Binder& binder) { - CALL("MatchingUtils::matchReversedArgs/3"); ASS_EQ(base->functor(), instance->functor()); ASS_EQ(base->arity(), 2); ASS_EQ(instance->arity(), 2); @@ -313,7 +306,6 @@ bool MatchingUtils::matchReversedArgs(Literal* base, Literal* instance, Binder& template bool MatchingUtils::matchArgs(Term* base, Term* instance, Binder& binder) { - CALL("MatchingUtils::matchArgs"); ASS_EQ(base->functor(),instance->functor()); if(base->shared() && instance->shared()) { if(base->weight() > instance->weight()) { diff --git a/Kernel/MaximalLiteralSelector.cpp b/Kernel/MaximalLiteralSelector.cpp index a465a3faa..d3bfd1c43 100644 --- a/Kernel/MaximalLiteralSelector.cpp +++ b/Kernel/MaximalLiteralSelector.cpp @@ -27,8 +27,6 @@ using namespace Kernel; void MaximalLiteralSelector::doSelection(Clause* c, unsigned eligible) { - CALL("MaximalLiteralSelector::doSelection"); - LiteralList* sel=0; bool anyNegative=false; diff --git a/Kernel/MismatchHandler.cpp b/Kernel/MismatchHandler.cpp index 13ceebd64..3bac2700d 100644 --- a/Kernel/MismatchHandler.cpp +++ b/Kernel/MismatchHandler.cpp @@ -30,8 +30,6 @@ namespace Kernel bool UWAMismatchHandler::handle(RobSubstitution* sub, TermList t1, unsigned index1, TermList t2, unsigned index2) { - CALL("UWAMismatchHandler::handle"); - TermList tt1 = sub->apply(t1,index1); TermList tt2 = sub->apply(t2,index2); @@ -43,8 +41,6 @@ bool UWAMismatchHandler::handle(RobSubstitution* sub, TermList t1, unsigned inde bool UWAMismatchHandler::checkUWA(TermList t1, TermList t2) { - CALL("UWAMismatchHandler::checkUWA"); - if(!(t1.isTerm() && t2.isTerm())) return false; if(t1.term()->isSort() || t2.term()->isSort()) return false; @@ -87,8 +83,6 @@ bool UWAMismatchHandler::introduceConstraint(TermList t1,unsigned index1, TermLi bool HOMismatchHandler::handle(RobSubstitution* sub, TermList t1, unsigned index1, TermList t2, unsigned index2) { - CALL("HOMismatchHandler::handle"); - auto constraint = make_pair(make_pair(t1,index1),make_pair(t2,index2)); constraints.push(constraint); return true; diff --git a/Kernel/OperatorType.cpp b/Kernel/OperatorType.cpp index 130cccac2..66e18fc86 100644 --- a/Kernel/OperatorType.cpp +++ b/Kernel/OperatorType.cpp @@ -32,8 +32,6 @@ using namespace Kernel; */ OperatorType::OperatorKey* OperatorType::setupKey(unsigned arity, const TermList* sorts) { - CALL("OperatorType::setupKey(unsigned,const unsigned*)"); - OperatorKey* key = OperatorKey::allocate(arity+1); if (!sorts) { @@ -56,8 +54,6 @@ OperatorType::OperatorKey* OperatorType::setupKey(unsigned arity, const TermList */ OperatorType::OperatorKey* OperatorType::setupKey(std::initializer_list sorts) { - CALL("OperatorType::setupKey(std::initializer_list)"); - OperatorKey* key = OperatorKey::allocate(sorts.size()+1); // initialise all the argument types to those taken from sorts @@ -75,7 +71,6 @@ OperatorType::OperatorKey* OperatorType::setupKey(std::initializer_listisSort()); OperatorKey* key = OperatorKey::allocate(arity+1); @@ -107,8 +102,6 @@ OperatorType::OperatorTypes& OperatorType::operatorTypes() { */ OperatorType* OperatorType::getTypeFromKey(OperatorType::OperatorKey* key, unsigned taArity) { - CALL("OperatorType::getTypeFromKey"); - /* cout << "getTypeFromKey(" << key->length() << "): "; for (unsigned i = 0; i < key->length(); i++) { @@ -141,8 +134,6 @@ OperatorType* OperatorType::getTypeFromKey(OperatorType::OperatorKey* key, unsig */ vstring OperatorType::argsToString() const { - CALL("OperatorType::argsToString"); - unsigned ar = arity(); ASS(ar); vstring res = ar > 1 ? "(" : ""; @@ -161,8 +152,6 @@ vstring OperatorType::argsToString() const */ vstring OperatorType::toString() const { - CALL("OperatorType::toString"); - vstring res; bool bracket = false; if(_typeArgsArity){ @@ -186,8 +175,6 @@ vstring OperatorType::toString() const */ bool OperatorType::isSingleSortType(TermList srt) const { - CALL("OperatorType::isSingleSortType"); - unsigned len = arity(); for (unsigned i = 0; i sorts, unsigned taArity = 0) { - CALL("OperatorType::getPredicateType(std::initializer_list)"); - OperatorKey* key = setupKey(sorts); (*key)[sorts.size()] = getEmpty(); return getTypeFromKey(key,taArity); } static OperatorType* getPredicateTypeUniformRange(unsigned arity, TermList argsSort, unsigned taArity = 0) { - CALL("OperatorType::getPredicateTypeUniformRange"); - OperatorKey* key = setupKeyUniformRange(arity,argsSort); (*key)[arity] = getEmpty(); return getTypeFromKey(key, taArity); } static OperatorType* getFunctionType(unsigned arity, const TermList* sorts, TermList resultSort, unsigned taArity = 0) { - CALL("OperatorType::getFunctionType"); - OperatorKey* key = setupKey(arity,sorts); (*key)[arity] = resultSort; return getTypeFromKey(key, taArity); } static OperatorType* getFunctionType(std::initializer_list sorts, TermList resultSort, unsigned taArity = 0) { - CALL("OperatorType::getFunctionType(std::initializer_list)"); - OperatorKey* key = setupKey(sorts); (*key)[sorts.size()] = resultSort; return getTypeFromKey(key,taArity); } static OperatorType* getFunctionTypeUniformRange(unsigned arity, TermList argsSort, TermList resultSort, unsigned taArity = 0) { - CALL("OperatorType::getFunctionTypeUniformRange"); - OperatorKey* key = setupKeyUniformRange(arity,argsSort); (*key)[arity] = resultSort; return getTypeFromKey(key,taArity); @@ -182,7 +170,6 @@ class OperatorType */ TermList quantifiedVar(unsigned idx) const { - CALL("OperatorType::quantifiedVar"); ASS(idx < _typeArgsArity); return TermList(idx, false); } @@ -194,7 +181,6 @@ class OperatorType */ TermList arg(unsigned idx) const { - CALL("OperatorType::arg"); if(idx < _typeArgsArity){ return AtomicSort::superSort(); } @@ -211,7 +197,6 @@ class OperatorType * The result sort of function types; or empty for predicates. */ TermList result() const { - CALL("OperatorType::result"); return (*_key)[arity() - numTypeArguments()]; } diff --git a/Kernel/Ordering.cpp b/Kernel/Ordering.cpp index 5a1145a5d..36c043f85 100644 --- a/Kernel/Ordering.cpp +++ b/Kernel/Ordering.cpp @@ -53,16 +53,12 @@ OrderingSP Ordering::s_globalOrdering; Ordering::Ordering() { - CALL("Ordering::Ordering"); - createEqualityComparator(); ASS(_eqCmp); } Ordering::~Ordering() { - CALL("Ordering::~Ordering"); - destroyEqualityComparator(); } @@ -79,8 +75,6 @@ Ordering::~Ordering() */ bool Ordering::trySetGlobalOrdering(OrderingSP ordering) { - CALL("Ordering::trySetGlobalOrdering"); - if(s_globalOrdering) { return false; } @@ -100,8 +94,6 @@ bool Ordering::trySetGlobalOrdering(OrderingSP ordering) */ Ordering* Ordering::tryGetGlobalOrdering() { - CALL("Ordering::tryGetGlobalOrdering"); - if(s_globalOrdering) { return s_globalOrdering.ptr(); } @@ -117,8 +109,6 @@ Ordering* Ordering::tryGetGlobalOrdering() */ Ordering* Ordering::create(Problem& prb, const Options& opt) { - CALL("Ordering::create"); - if(env.options->combinatorySup() || env.options->lambdaFreeHol()){ return new SKIKBO(prb, opt, env.options->lambdaFreeHol()); } @@ -162,8 +152,6 @@ Ordering* Ordering::create(Problem& prb, const Options& opt) Ordering::Result Ordering::fromComparison(Comparison c) { - CALL("Ordering::fromComparison"); - switch(c) { case Lib::GREATER: return GREATER; @@ -178,8 +166,6 @@ Ordering::Result Ordering::fromComparison(Comparison c) Comparison Ordering::intoComparison(Ordering::Result r) { - CALL("Ordering::intoComparison"); - switch(r) { case Ordering::Result::GREATER: return Lib::GREATER; case Ordering::Result::EQUAL: return Lib::EQUAL; @@ -191,8 +177,6 @@ Comparison Ordering::intoComparison(Ordering::Result r) const char* Ordering::resultToString(Result r) { - CALL("Ordering::resultToString"); - switch(r) { case GREATER: return "GREATER"; @@ -218,8 +202,6 @@ const char* Ordering::resultToString(Result r) */ void Ordering::removeNonMaximal(LiteralList*& lits) const { - CALL("Ordering::removeNonMaximal"); - LiteralList** ptr1 = &lits; while (*ptr1) { LiteralList** ptr2 = &(*ptr1)->tailReference(); @@ -243,7 +225,6 @@ void Ordering::removeNonMaximal(LiteralList*& lits) const Ordering::Result Ordering::getEqualityArgumentOrder(Literal* eq) const { - CALL("Ordering::getEqualityArgumentOrder"); ASS(eq->isEquality()); if(tryGetGlobalOrdering()!=this) { @@ -269,7 +250,6 @@ Ordering::Result Ordering::getEqualityArgumentOrder(Literal* eq) const Ordering::Result PrecedenceOrdering::compare(Literal* l1, Literal* l2) const { - CALL("PrecedenceOrdering::compare(Literal*...)"); ASS(l1->shared()); ASS(l2->shared()); @@ -357,8 +337,6 @@ int PrecedenceOrdering::predicatePrecedence (unsigned pred) const */ //TODO update for HOL>? Ordering::Result PrecedenceOrdering::compareFunctionPrecedences(unsigned fun1, unsigned fun2) const { - CALL("PrecedenceOrdering::compareFunctionPrecedences"); - if (fun1 == fun2) return EQUAL; @@ -465,8 +443,6 @@ Ordering::Result PrecedenceOrdering::compareFunctionPrecedences(unsigned fun1, u */ Ordering::Result PrecedenceOrdering::compareTypeConPrecedences(unsigned tyc1, unsigned tyc2) const { - CALL("PrecedenceOrdering::compareTypeConPrecedences"); - auto size = _typeConPrecedences.size(); if (tyc1 == tyc2) @@ -615,8 +591,6 @@ template using ConstFirstComparator = SpecAriFirstComparator<0,revert,InnerComparator>; static void loadPermutationFromString(DArray& p, const vstring& str) { - CALL("loadPermutationFromString"); - std::stringstream ss(str.c_str()); unsigned i = 0; unsigned val; @@ -638,7 +612,6 @@ static void loadPermutationFromString(DArray& p, const vstring& str) { } bool isPermutation(const DArray& xs) { - CALL("isPermutation"); DArray cnts(xs.size()); cnts.init(xs.size(), 0); for (unsigned i = 0; i < xs.size(); i++) { @@ -668,7 +641,6 @@ PrecedenceOrdering::PrecedenceOrdering(const DArray& funcPrec, _typeConPrecedences(typeConPrec), _reverseLCM(reverseLCM) { - CALL("PrecedenceOrdering::PrecedenceOrdering(const DArray&, const DArray&, const DArray&, bool)"); ASS_EQ(env.signature->predicates(), _predicates); ASS_EQ(env.signature->functions(), _functions); ASS(isPermutation(_functionPrecedences)) @@ -689,7 +661,6 @@ PrecedenceOrdering::PrecedenceOrdering(Problem& prb, const Options& opt, const D opt.literalComparisonMode()==Shell::Options::LiteralComparisonMode::REVERSE ) { - CALL("PrecedenceOrdering::PrecedenceOrdering((Problem&,const Options&,const DArray&)"); } /** @@ -703,13 +674,10 @@ PrecedenceOrdering::PrecedenceOrdering(Problem& prb, const Options& opt) prb.getProperty(), predPrecFromOpts(prb, opt))) { - CALL("PrecedenceOrdering::PrecedenceOrdering(Problem&,const Options&)"); ASS_G(_predicates, 0); } static void sortAuxBySymbolPrecedence(DArray& aux, const Options& opt, SymbolType symType) { - CALL("sortAuxBySymbolPrecedence"); - // since the below sorts are stable, a proper input shuffling manifests itself (also) by initializing aux with a random permutation rather then the identity one if (opt.shuffleInput() && opt.symbolPrecedence() != Shell::Options::SymbolPrecedence::SCRAMBLE) { Shuffling::shuffleArray(aux,aux.size()); @@ -763,8 +731,6 @@ static void sortAuxBySymbolPrecedence(DArray& aux, const Options& opt, DArray PrecedenceOrdering::typeConPrecFromOpts(Problem& prb, const Options& opt) { - CALL("PrecedenceOrdering::typeConPresFromOpts"); - unsigned nTypeCons = env.signature->typeCons(); DArray aux(nTypeCons); @@ -793,8 +759,6 @@ DArray PrecedenceOrdering::typeConPrecFromOpts(Problem& prb, const Options& } DArray PrecedenceOrdering::funcPrecFromOpts(Problem& prb, const Options& opt) { - CALL("PrecedenceOrdering::funcPrecFromOpts"); - unsigned nFunctions = env.signature->functions(); DArray aux(nFunctions); @@ -823,8 +787,6 @@ DArray PrecedenceOrdering::funcPrecFromOpts(Problem& prb, const Options& op } DArray PrecedenceOrdering::predPrecFromOpts(Problem& prb, const Options& opt) { - CALL("PrecedenceOrdering::typeConPresFromOpts"); - unsigned nPredicates = env.signature->predicates(); DArray aux(nPredicates); aux.initFromIterator(getRangeIterator(0u, nPredicates), nPredicates); @@ -900,8 +862,6 @@ DArray PrecedenceOrdering::predLevelsFromOptsAndPrec(Problem& prb, const Op void PrecedenceOrdering::show(ostream& out) const { - CALL("PrecedenceOrdering::show(ostream& out)"); - auto _show = [&](const char* precKind, unsigned cntFunctors, auto getSymbol, auto compareFunctors) { out << "% " << precKind << " precedences, smallest symbols first (line format: ` `) " << std::endl; diff --git a/Kernel/Ordering.hpp b/Kernel/Ordering.hpp index 4b1b987a6..90b3b5c39 100644 --- a/Kernel/Ordering.hpp +++ b/Kernel/Ordering.hpp @@ -77,8 +77,6 @@ class Ordering static Result reverse(Result r) { - CALL("Ordering::reverse"); - switch(r) { case GREATER: return LESS; diff --git a/Kernel/Ordering_Equality.cpp b/Kernel/Ordering_Equality.cpp index 92e605605..52c17d7a6 100644 --- a/Kernel/Ordering_Equality.cpp +++ b/Kernel/Ordering_Equality.cpp @@ -71,15 +71,11 @@ class Ordering::EqCmp void Ordering::createEqualityComparator() { - CALL("Ordering::createEqualityComparator"); - _eqCmp=new EqCmp(this); } void Ordering::destroyEqualityComparator() { - CALL("Ordering::destroyEqualityComparator"); - delete _eqCmp; #if VDEBUG _eqCmp=0; @@ -89,7 +85,6 @@ void Ordering::destroyEqualityComparator() Ordering::Result Ordering::compareEqualities(Literal* eq1, Literal* eq2) const { - CALL("Ordering::compareEqualities"); ASS(eq1->isEquality()); ASS(eq2->isEquality()); @@ -110,7 +105,6 @@ Ordering::Result Ordering::compareEqualities(Literal* eq1, Literal* eq2) const Ordering::Result Ordering::EqCmp::compareEqualities(Literal* eq1, Literal* eq2) const { - CALL("Ordering::EqCmp::compareEqualities"); ASS(eq1->isEquality()); ASS(eq2->isEquality()); @@ -153,7 +147,6 @@ Ordering::Result Ordering::EqCmp::compareEqualities(Literal* eq1, Literal* eq2) */ Ordering::Result Ordering::EqCmp::compare_s1Gt1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1"); ASS_EQ(compare(s1,t1), GREATER); switch(compare(s2,t2)) { @@ -176,7 +169,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1(TermList s1,TermList s2,TermList */ Ordering::Result Ordering::EqCmp::compare_s1GEt1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1"); ASS_EQ(compare(s1,t1), GREATER_EQ); switch(compare(s2,t2)) { @@ -200,7 +192,6 @@ Ordering::Result Ordering::EqCmp::compare_s1GEt1(TermList s1,TermList s2,TermLis */ Ordering::Result Ordering::EqCmp::compare_s1It1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1It1"); ASS_EQ(compare(s1,t1), INCOMPARABLE); switch(compare(s2,t2)) { @@ -224,7 +215,6 @@ Ordering::Result Ordering::EqCmp::compare_s1It1(TermList s1,TermList s2,TermList */ Ordering::Result Ordering::EqCmp::compare_s1It1_s2It2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1It1_s2It2"); ASS_EQ(compare(s1,t1), INCOMPARABLE); ASS_EQ(compare(s2,t2), INCOMPARABLE); @@ -249,7 +239,6 @@ Ordering::Result Ordering::EqCmp::compare_s1It1_s2It2(TermList s1,TermList s2,Te */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2It2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s2It2"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s2,t2), INCOMPARABLE); @@ -276,7 +265,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2It2(TermList s1,TermList s2,Te */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2Lt2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s2Lt2"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s2,t2), LESS); @@ -309,7 +297,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2Lt2(TermList s1,TermList s2,Te */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2LEt2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s2LEt2"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s2,t2), LESS_EQ); @@ -337,7 +324,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s2LEt2(TermList s1,TermList s2,T */ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s2It2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1_s2It2"); ASS_EQ(compare(s1,t1), GREATER_EQ); ASS_EQ(compare(s2,t2), INCOMPARABLE); @@ -365,7 +351,6 @@ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s2It2(TermList s1,TermList s2,T */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1It2_s2It1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s1It2_s2It1"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s1,t2), INCOMPARABLE); ASS_EQ(compare(s2,t1), INCOMPARABLE); @@ -388,7 +373,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1It2_s2It1(TermList s1,TermList */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It1"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s1,t2), GREATER_EQ); ASS_EQ(compare(s2,t1), INCOMPARABLE); @@ -415,7 +399,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It1(TermList s1,TermLis */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It2"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s1,t2), GREATER_EQ); ASS_EQ(compare(s2,t2), INCOMPARABLE); @@ -443,7 +426,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2It2(TermList s1,TermLis */ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s1GEt2_s2It1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1_s1GEt2_s2It1"); ASS_EQ(compare(s1,t1), GREATER_EQ); ASS_EQ(compare(s1,t2), GREATER_EQ); ASS_EQ(compare(s2,t1), INCOMPARABLE); @@ -471,7 +453,6 @@ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s1GEt2_s2It1(TermList s1,TermLi */ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s1It2_s2It1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1_s1It2_s2It1"); ASS_EQ(compare(s1,t1), GREATER_EQ); ASS_EQ(compare(s1,t2), INCOMPARABLE); ASS_EQ(compare(s2,t1), INCOMPARABLE); @@ -508,7 +489,6 @@ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s1It2_s2It1(TermList s1,TermLis */ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s2LEt2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1_s2LEt2"); ASS_EQ(compare(s1,t1), GREATER_EQ); ASS_EQ(compare(s2,t2), LESS_EQ); @@ -550,7 +530,6 @@ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s2LEt2(TermList s1,TermList s2, */ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2Lt2(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2Lt2"); ASS_EQ(compare(s1,t1), GREATER); ASS_EQ(compare(s1,t2), GREATER_EQ); ASS_EQ(compare(s2,t2), LESS); @@ -580,7 +559,6 @@ Ordering::Result Ordering::EqCmp::compare_s1Gt1_s1GEt2_s2Lt2(TermList s1,TermLis */ Ordering::Result Ordering::EqCmp::compare_s1GEt1_s1GEt2_s2LEt1(TermList s1,TermList s2,TermList t1,TermList t2) const { - CALL("Ordering::EqCmp::compare_s1GEt1_s1GEt2_s2LEt1"); ASS_EQ(compare(s1,t1), GREATER_EQ); ASS_EQ(compare(s1,t2), GREATER_EQ); ASS_EQ(compare(s2,t1), LESS_EQ); diff --git a/Kernel/Polynomial.cpp b/Kernel/Polynomial.cpp index 18cfe4fc3..c1d90a136 100644 --- a/Kernel/Polynomial.cpp +++ b/Kernel/Polynomial.cpp @@ -192,7 +192,6 @@ PolyNf::SubtermIter::SubtermIter(PolyNf p) PolyNf PolyNf::SubtermIter::next() { - CALL("PolyNf::SubtermIter::next") ASS(_stack.size() != 0) while(_stack.top().hasNext()) { ASS(_stack.size() != 0) @@ -204,7 +203,6 @@ PolyNf PolyNf::SubtermIter::next() bool PolyNf::SubtermIter::hasNext() const { - CALL("PolyNf::SubtermIter::hasNext") return !_stack.isEmpty(); } diff --git a/Kernel/Polynomial.hpp b/Kernel/Polynomial.hpp index b9802713d..4425b6dde 100644 --- a/Kernel/Polynomial.hpp +++ b/Kernel/Polynomial.hpp @@ -891,8 +891,6 @@ bool operator==(const MonomFactors& l, const MonomFactors& r) { template TermList MonomFactors::denormalize(TermList* results) const { - CALL("MonomFactors::denormalize()") - if (_factors.size() == 0) { return Number::one(); } else { @@ -1068,8 +1066,6 @@ typename Number::ConstantType Polynom::unwrapNumber() const& template TermList Polynom::denormalize(TermList* results) const { - CALL("Polynom::denormalize()") - auto monomToTerm = [](Monom const& monom, TermList* t) -> TermList { auto c = TermList(theory->representConstant(monom.numeral)); if (monom.factors->isOne()) { @@ -1109,7 +1105,6 @@ Stack>& Polynom::raw() template Polynom Polynom::replaceTerms(PolyNf* simplifiedTerms) const { - CALL("Polynom::replaceTerms(PolyNf*)") int offs = 0; Stack out; out.reserve(nSummands()); diff --git a/Kernel/PolynomialNormalizer.cpp b/Kernel/PolynomialNormalizer.cpp index c7f232619..c2ab1c43d 100644 --- a/Kernel/PolynomialNormalizer.cpp +++ b/Kernel/PolynomialNormalizer.cpp @@ -20,7 +20,6 @@ struct RenderMonom { template Monom operator()(MonomFactors&& x) const { - CALL("RenderMonom::operator()(MonomFactors&&)") using Numeral = typename NumTraits::ConstantType; using Monom = Monom ; auto& raw = x.raw(); @@ -85,7 +84,6 @@ struct RenderPolyNf { template NormalizationResult normalizeAdd(NormalizationResult& lhs, NormalizationResult& rhs) { - CALL("normalizeAdd") using Polynom = Polynom; using Monom = Monom; using MonomFactors = MonomFactors; @@ -133,7 +131,6 @@ NormalizationResult normalizeAdd(NormalizationResult& lhs, NormalizationResult& template NormalizationResult normalizeMul(NormalizationResult& lhs, NormalizationResult& rhs) { - CALL("normalizeMul") using Polynom = Polynom; using MonomFactors = MonomFactors; using MonomFactor = MonomFactor; @@ -276,7 +273,6 @@ NormalizationResult normalizeMinus(NormalizationResult& x) { template NormalizationResult normalizeNumSort(TermList t, NormalizationResult* ts) { - CALL("normalizeNumSort(TermList,NormalizationResult)") auto singletonProduct = [](PolyNf t) -> NormalizationResult { return NormalizationResult(MonomFactors(t)); }; @@ -326,7 +322,6 @@ NormalizationResult normalizeNumSort(TermList t, NormalizationResult* ts) PolyNf normalizeTerm(TypedTermList t) { - CALL("PolyNf::normalize") DEBUG("normalizing ", t) Memo::None memo; struct Eval @@ -336,7 +331,6 @@ PolyNf normalizeTerm(TypedTermList t) NormalizationResult operator()(TypedTermList t, NormalizationResult* ts) const { - CALL("normalizeTerm(TypedTermList)::eval::operator()") auto sort = t.sort(); if (sort == IntTraits::sort()) { return normalizeNumSort< IntTraits>(t, ts); } if (sort == RatTraits::sort()) { return normalizeNumSort< RatTraits>(t, ts); } @@ -364,7 +358,6 @@ PolyNf normalizeTerm(TypedTermList t) TermList PolyNf::denormalize() const { - CALL("PolyNf::denormalize") DEBUG("converting ", *this) struct Eval { diff --git a/Kernel/PolynomialNormalizer.hpp b/Kernel/PolynomialNormalizer.hpp index 1740418ff..71802d54d 100644 --- a/Kernel/PolynomialNormalizer.hpp +++ b/Kernel/PolynomialNormalizer.hpp @@ -21,7 +21,6 @@ #include "Term.hpp" #include "Theory.hpp" #include "NumTraits.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Coproduct.hpp" #include #include @@ -30,7 +29,6 @@ #include "Lib/Hash.hpp" #include "Lib/Environment.hpp" #include "Lib/Option.hpp" -#include "Debug/Tracer.hpp" #include "Kernel/Polynomial.hpp" #include "Inferences/InferenceEngine.hpp" diff --git a/Kernel/PolynomialNormalizer/PredicateEvaluator.hpp b/Kernel/PolynomialNormalizer/PredicateEvaluator.hpp index 9d50d5c0a..7a3c91821 100644 --- a/Kernel/PolynomialNormalizer/PredicateEvaluator.hpp +++ b/Kernel/PolynomialNormalizer/PredicateEvaluator.hpp @@ -12,7 +12,6 @@ template struct PredicateEvaluator; template using Poly = Polynom>; -#include "Debug/Tracer.hpp" #include "Lib/STLAllocator.hpp" #include "Lib/Option.hpp" @@ -24,7 +23,6 @@ using LitSimplResult = Inferences::SimplifyingGeneratingLiteralSimplification::R struct PredicateEvaluator { \ static Option evaluate(Literal* orig, PolyNf* evaluatedArgs) \ { \ - CALL("PredicateEvaluator<" #interpretation ">::evaluate(Literal*,PolyNf*)"); \ __VA_ARGS__ \ } \ }; diff --git a/Kernel/Problem.cpp b/Kernel/Problem.cpp index 12cf62ee3..6df9d6f3e 100644 --- a/Kernel/Problem.cpp +++ b/Kernel/Problem.cpp @@ -40,8 +40,6 @@ using namespace Kernel; Problem::Problem(UnitList* units) : _units(0), _smtlibLogic(SMTLIBLogic::SMT_UNDEFINED), _property(0) { - CALL("Problem::Problem(UnitList*)"); - initValues(); addUnits(units); @@ -56,8 +54,6 @@ Problem::Problem(UnitList* units) Problem::Problem(ClauseIterator clauses, bool copy) : _units(0), _property(0) { - CALL("Problem::Problem(ClauseIterator,bool)"); - initValues(); UnitList* units = 0; @@ -74,7 +70,6 @@ Problem::Problem(ClauseIterator clauses, bool copy) Problem::~Problem() { - CALL("Problem::~Problem"); //TODO: decrease reference counter of clauses (but make sure there's no segfault...) UnitList::destroy(_units); @@ -89,8 +84,6 @@ Problem::~Problem() */ void Problem::initValues() { - CALL("Problem::initValues"); - _hadIncompleteTransformation = false; _mayHaveEquality = true; _mayHaveFormulas = true; @@ -107,8 +100,6 @@ void Problem::initValues() */ void Problem::addUnits(UnitList* newUnits) { - CALL("Problem::addUnits"); - UnitList::Iterator uit(newUnits); while(uit.hasNext()) { Unit* u = uit.next(); @@ -134,8 +125,6 @@ void Problem::addUnits(UnitList* newUnits) */ ClauseIterator Problem::clauseIterator() const { - CALL("Problem::clauseIterator"); - //we first call mayHaveFormulas(). if this returns false, we know there are //no formulas. otherwise we call hasFormulas() which may cause rescanning //the problem property @@ -153,8 +142,6 @@ ClauseIterator Problem::clauseIterator() const */ Problem* Problem::copy(bool copyClauses) { - CALL("Problem::copy/1"); - Problem* res = new Problem(); copyInto(*res, copyClauses); return res; @@ -170,8 +157,6 @@ Problem* Problem::copy(bool copyClauses) */ void Problem::copyInto(Problem& tgt, bool copyClauses) { - CALL("Problem::copy/2"); - tgt.setSMTLIBLogic(getSMTLIBLogic()); if(copyClauses) { @@ -219,8 +204,6 @@ void Problem::copyInto(Problem& tgt, bool copyClauses) */ void Problem::addTrivialPredicate(unsigned pred, bool assignment) { - CALL("Problem::addTrivialPredicate"); - ALWAYS(_trivialPredicates.insert(pred, assignment)); } @@ -231,7 +214,6 @@ void Problem::addTrivialPredicate(unsigned pred, bool assignment) */ void Problem::addEliminatedFunction(unsigned func, Literal* definition) { - CALL("Problem::addEliminatedFunction"); ASS(definition->isEquality()); _deletedFunctions.insert(func,definition); @@ -244,8 +226,6 @@ void Problem::addEliminatedFunction(unsigned func, Literal* definition) */ void Problem::addEliminatedPredicate(unsigned pred, Unit* definition) { - CALL("Problem::addEliminatedPredicate"); - _deletedPredicates.insert(pred,definition); } @@ -256,8 +236,6 @@ void Problem::addEliminatedPredicate(unsigned pred, Unit* definition) */ void Problem::addPartiallyEliminatedPredicate(unsigned pred, Unit* definition) { - CALL("Problem::addPurePredicateDefinition"); - _partiallyDeletedPredicates.insert(pred,definition); } @@ -266,8 +244,6 @@ void Problem::addPartiallyEliminatedPredicate(unsigned pred, Unit* definition) */ void Problem::refreshProperty() const { - CALL("Problem::refreshProperty"); - TIME_TRACE(TimeTrace::PROPERTY_EVALUATION); ScopedLet phaseLet(env.statistics->phase, Statistics::PROPERTY_SCANNING); @@ -286,8 +262,6 @@ void Problem::refreshProperty() const */ void Problem::readDetailsFromProperty() const { - CALL("Problem::readDetailsFromProperty"); - _hasFormulas = _property->hasFormulas(); _hasEquality = _property->equalityAtoms()!=0; _hasInterpretedOperations = _property->hasInterpretedOperations(); @@ -315,8 +289,6 @@ void Problem::readDetailsFromProperty() const */ void Problem::invalidateEverything() { - CALL("Problem::invalidateEverything"); - invalidateProperty(); _hasFormulas = MaybeBool::UNKNOWN; _hasEquality = MaybeBool::UNKNOWN; @@ -340,8 +312,6 @@ void Problem::invalidateEverything() */ void Problem::invalidateByRemoval() { - CALL("Problem::invalidateByRemoval"); - invalidateProperty(); _hasFormulas.mightBecameFalse(); _hasEquality.mightBecameFalse(); @@ -361,8 +331,6 @@ void Problem::invalidateByRemoval() */ Property* Problem::getProperty() const { - CALL("Problem::getProperty"); - if(!_propertyValid) { refreshProperty(); } @@ -374,8 +342,6 @@ Property* Problem::getProperty() const bool Problem::hasFormulas() const { - CALL("Problem::hasFormulas"); - if(!mayHaveFormulas()) { return false; } if(!_hasFormulas.known()) { refreshProperty(); } ASS(_hasFormulas.known()); @@ -384,8 +350,6 @@ bool Problem::hasFormulas() const bool Problem::hasEquality() const { - CALL("Problem::hasEquality"); - if(!mayHaveEquality()) { return false; } if(!_hasEquality.known()) { refreshProperty(); } return _hasEquality.value(); @@ -393,32 +357,24 @@ bool Problem::hasEquality() const bool Problem::hasInterpretedOperations() const { - CALL("Problem::hasInterpretedOperations"); - if(!_hasInterpretedOperations.known()) { refreshProperty(); } return _hasInterpretedOperations.value(); } bool Problem::hasNumerals() const { - CALL("Problem::hasNumerals"); - if(!_hasNumerals.known()) { refreshProperty(); } return _hasNumerals.value(); } bool Problem::hasFOOL() const { - CALL("Problem::hasFOOL"); - if(!_hasFOOL.known()) { refreshProperty(); } return _hasFOOL.value(); } bool Problem::hasCombs() const { - CALL("Problem::hasCombs"); - if(!_hasCombs.known()) { refreshProperty(); } return _hasCombs.value(); } @@ -426,24 +382,18 @@ bool Problem::hasCombs() const bool Problem::hasApp() const { - CALL("Problem::hasApp"); - if(!_hasApp.known()) { refreshProperty(); } return _hasApp.value(); } bool Problem::hasAppliedVar() const { - CALL("Problem::hasAppliedVar"); - if(!_hasAppliedVar.known()) { refreshProperty(); } return _hasAppliedVar.value(); } bool Problem::hasBoolVar() const { - CALL("Problem::hasBoolVar"); - if(!_hasBoolVar.known()) { refreshProperty(); } return _hasBoolVar.value(); } @@ -451,40 +401,30 @@ bool Problem::hasBoolVar() const bool Problem::hasLogicalProxy() const { - CALL("Problem::hasLogicalProxy"); - if(!_hasLogicalProxy.known()) { refreshProperty(); } return _hasLogicalProxy.value(); } bool Problem::hasPolymorphicSym() const { - CALL("Problem::hasPolymorphicSym"); - if(!_hasPolymorphicSym.known()) { refreshProperty(); } return _hasPolymorphicSym.value(); } bool Problem::quantifiesOverPolymorphicVar() const { - CALL(" Problem::quantifiesOverPolymorphicVar"); - if(!_quantifiesOverPolymorphicVar.known()) { refreshProperty(); } return _quantifiesOverPolymorphicVar.value(); } bool Problem::isHigherOrder() const { - CALL("Problem::hasPolymorphicSym"); - if(!_higherOrder.known()) { refreshProperty(); } return _higherOrder.value(); } bool Problem::hasNonDefaultSorts() const { - CALL("Problem::hasNonDefaultSorts"); - if(!_hasNonDefaultSorts.known()) { refreshProperty(); } return _hasNonDefaultSorts.value(); } @@ -495,8 +435,6 @@ bool Problem::hasNonDefaultSorts() const // void Problem::assertValid() { - CALL("Problem::assertValid"); - UnitList::Iterator uit(units()); while(uit.hasNext()) { Unit* u = uit.next(); diff --git a/Kernel/Problem.hpp b/Kernel/Problem.hpp index 456ab033a..8f62ca865 100644 --- a/Kernel/Problem.hpp +++ b/Kernel/Problem.hpp @@ -123,7 +123,6 @@ class Problem { _smtlibLogic = smtLibLogic; } SMTLIBLogic getSMTLIBLogic() const { - CALL("Kernel::Problem::getSMTLIBLogic"); return _smtlibLogic; } diff --git a/Kernel/RCClauseStack.hpp b/Kernel/RCClauseStack.hpp index 4503b6183..719052511 100644 --- a/Kernel/RCClauseStack.hpp +++ b/Kernel/RCClauseStack.hpp @@ -32,23 +32,17 @@ class RCClauseStack { public: void push(Clause* cl) { - CALL("RCClauseStack::push"); - cl->incRefCnt(); _s.push(cl); } void pushWithoutInc(Clause* cl) { - CALL("RCClauseStack::push"); - _s.push(cl); } Clause* pop() { - CALL("RCClauseStack::pop"); - Clause* cl=_s.pop(); cl->decRefCnt(); return cl; @@ -60,8 +54,6 @@ class RCClauseStack { */ Clause* popWithoutDec() { - CALL("RCClauseStack::popWithoutDec"); - return _s.pop(); } @@ -124,8 +116,6 @@ class RCClauseStack { bool find(Clause* cl) const { - CALL("RCClauseStack::find"); - Iterator it(const_cast(*this)); while(it.hasNext()) { if(it.next()==cl) { diff --git a/Kernel/Rebalancing.hpp b/Kernel/Rebalancing.hpp index 523543e21..a323e6360 100644 --- a/Kernel/Rebalancing.hpp +++ b/Kernel/Rebalancing.hpp @@ -18,8 +18,6 @@ #define DEBUG(...) // DBG(__VA_ARGS__) -#define CALL_DBG(...) CALL(__VA_ARGS__) - namespace Kernel { namespace Rebalancing { @@ -135,7 +133,6 @@ template BalanceIter::BalanceIter(const Balancer& balancer, bool , _litIndex(end ? 2 : 0) , _balancer(balancer) { - CALL_DBG("BalanceIter()") if (end) { DEBUG("end") } else { @@ -175,7 +172,6 @@ template TermList BalanceIter::derefPath() const template bool BalanceIter::canInvert() const { - CALL("Balancer::canInver()") if (_path.isEmpty()) { DEBUG("can invert empty") return true;/* <- we can 'invert' an equality by doing nothing*/ @@ -187,9 +183,7 @@ template bool BalanceIter::canInvert() const /** moves to the next invertible point in the term */ template void BalanceIter::incrementPath() -{ - CALL_DBG("BalanceIter::incrementPath") - +{ auto peak = [&]() -> Node& { return _path.top(); }; auto incPeak = [&]() { ++peak()._index; @@ -240,16 +234,13 @@ template void BalanceIter::incrementPath() } template void BalanceIter::findNextVar() -{ - CALL_DBG("BalanceIter::findNextVar") - +{ while(inBounds() && !derefPath().isVar() ) { incrementPath(); } } -template void BalanceIter::operator++() { - CALL_DBG("BalanceIter::operator++") +template void BalanceIter::operator++() { incrementPath(); if (inBounds()) findNextVar(); @@ -257,15 +248,13 @@ template void BalanceIter::operator++() { template -const BalanceIter& BalanceIter::operator*() const { - CALL_DBG("BalanceIter::operator*") +const BalanceIter& BalanceIter::operator*() const { DEBUG(lhs()) return *this; } template -bool operator!=(const BalanceIter& lhs, const BalanceIter& rhs) { - CALL_DBG("BalanceIter::operator!=") +bool operator!=(const BalanceIter& lhs, const BalanceIter& rhs) { ASS(rhs._path.isEmpty()); auto out = lhs.inBounds();//!lhs._path.isEmpty() || lhs._litIndex != 2; return out; @@ -273,9 +262,8 @@ bool operator!=(const BalanceIter& lhs, const BalanceIter& rhs) { template -TermList BalanceIter::lhs() const +TermList BalanceIter::lhs() const { - // CALL_DBG("BalanceIter::lhs") auto out = derefPath(); ASS_REP(out.isVar(), out); // DEBUG(out) diff --git a/Kernel/Rebalancing/Inverters.cpp b/Kernel/Rebalancing/Inverters.cpp old mode 100755 new mode 100644 index 346486bbb..23f856344 --- a/Kernel/Rebalancing/Inverters.cpp +++ b/Kernel/Rebalancing/Inverters.cpp @@ -8,7 +8,6 @@ * and in the source directory */ #include "Inverters.hpp" -#include "Debug/Tracer.hpp" namespace Kernel { namespace Rebalancing { @@ -41,7 +40,6 @@ bool dtorIsPredicate(Signature::Symbol const& ctor, unsigned index) { return ctor.fnType()->arg(index) == AtomicSort::boolSort(); } bool NumberTheoryInverter::canInvertTop(const InversionContext &ctxt) { - CALL("NumberTheoryInverter::canInvertTop") auto &t = ctxt.topTerm(); auto fun = t.functor(); @@ -88,7 +86,6 @@ bool NumberTheoryInverter::canInvertTop(const InversionContext &ctxt) { CASE_DO_INVERT(IntegerConstantType, fun, expr) TermList NumberTheoryInverter::invertTop(const InversionContext &ctxt) { - CALL("NumberTheoryInverter::invertTop") ASS(canInvertTop(ctxt)) // DBG("inverting: ", ctxt.topTerm().toString()) auto &t = ctxt.topTerm(); @@ -117,8 +114,6 @@ TermList NumberTheoryInverter::invertTop(const InversionContext &ctxt) { template bool tryInvertDiv(const InversionContext &ctxt, TermList &out) { - CALL("tryInvertDiv(..)") - /* auto s = ctxt.topTerm()[0]; */ auto t = ctxt.topTerm()[1]; auto u = ctxt.toWrap(); @@ -139,7 +134,6 @@ bool tryInvertDiv(const InversionContext &ctxt, TermList &out) { template TermList doInvertDiv(const InversionContext &ctxt) { - CALL("doInvertDiv(...)") TermList out; ALWAYS(tryInvertDiv(ctxt, out)) return out; @@ -147,13 +141,11 @@ TermList doInvertDiv(const InversionContext &ctxt) { template bool canInvertDiv(const InversionContext &ctxt) { - CALL("canInvertDiv(const InversionContext&)") TermList _inv; return tryInvertDiv(ctxt, _inv); } bool tryInvertMulInt(const InversionContext &ctxt, TermList &out) { - CALL("tryInvertMulInt(..)") using Number = NumTraits; auto a_ = ctxt.topTerm()[1 - ctxt.topIdx()]; @@ -176,14 +168,12 @@ bool tryInvertMulInt(const InversionContext &ctxt, TermList &out) { } TermList doInvertMulInt(const InversionContext &ctxt) { - CALL("doInvertMulInt(...)") TermList out; ALWAYS(tryInvertMulInt(ctxt, out)) return out; } bool canInvertMulInt(const InversionContext &ctxt) { - CALL("canInvertMulInt(const InversionContext&)") TermList _inv; return tryInvertMulInt(ctxt, _inv); } diff --git a/Kernel/Renaming.cpp b/Kernel/Renaming.cpp index 05b641bd4..1e369aaf4 100644 --- a/Kernel/Renaming.cpp +++ b/Kernel/Renaming.cpp @@ -34,8 +34,6 @@ using namespace Indexing; Literal* Renaming::apply(Literal* lit) { - CALL("Renaming::apply(Literal*...)"); - if(identity()) { return lit; } @@ -45,8 +43,6 @@ Literal* Renaming::apply(Literal* lit) Term* Renaming::apply(Term* trm) { - CALL("Renaming::apply(Term*...)"); - if(identity()) { return trm; } @@ -56,8 +52,6 @@ Term* Renaming::apply(Term* trm) TermList Renaming::apply(TermList trm) { - CALL("Renaming::apply(TermList...)"); - if(identity()) { return trm; } @@ -123,7 +117,6 @@ void Renaming::makeInverse(const Renaming& orig) TypedTermList Renaming::normalize(TypedTermList l) { - CALL("Renaming::normalize(TypedTermList)"); if (l.isTerm()) { return TypedTermList(normalize(l.term())); } else { @@ -137,8 +130,6 @@ TypedTermList Renaming::normalize(TypedTermList l) Literal* Renaming::normalize(Literal* l) { - CALL("Renaming::normalize(Literal*)"); - Recycled n; n->normalizeVariables(l); return n->apply(l); @@ -146,8 +137,6 @@ Literal* Renaming::normalize(Literal* l) Term* Renaming::normalize(Term* trm) { - CALL("Renaming::normalize(Term*)"); - Recycled n; n->normalizeVariables(trm); return n->apply(trm); @@ -155,8 +144,6 @@ Term* Renaming::normalize(Term* trm) TermList Renaming::normalize(TermList trm) { - CALL("Renaming::normalize(TermList)"); - Recycled n; n->normalizeVariables(trm); return n->apply(trm); diff --git a/Kernel/RndLiteralSelector.cpp b/Kernel/RndLiteralSelector.cpp index 9e5d12588..bc69f7f99 100644 --- a/Kernel/RndLiteralSelector.cpp +++ b/Kernel/RndLiteralSelector.cpp @@ -28,8 +28,6 @@ using namespace Kernel; LiteralList* RndLiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligible) { - CALL("RndLiteralSelector::getMaximalsInOrder"); - LiteralList* res = LiteralList::empty(); for(int li=((int)eligible)-1; li>=0; li--) { @@ -43,8 +41,6 @@ LiteralList* RndLiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligible void RndLiteralSelector::doSelection(Clause* c, unsigned eligible) { - CALL("RndLiteralSelector::doSelection"); - LiteralList* sel = LiteralList::empty(); Literal* singleSel = nullptr; diff --git a/Kernel/RobSubstitution.cpp b/Kernel/RobSubstitution.cpp index de9a6635e..4666e9773 100644 --- a/Kernel/RobSubstitution.cpp +++ b/Kernel/RobSubstitution.cpp @@ -37,8 +37,6 @@ const int RobSubstitution::UNBOUND_INDEX=-1; */ bool RobSubstitution::unify(TermList t1,int index1, TermList t2, int index2, MismatchHandler* hndlr) { - CALL("RobSubstitution::unify/4"); - return unify(TermSpec(t1,index1), TermSpec(t2,index2),hndlr); } @@ -49,7 +47,6 @@ bool RobSubstitution::unify(TermList t1,int index1, TermList t2, int index2, Mis */ bool RobSubstitution::unifyArgs(Term* t1,int index1, Term* t2, int index2, MismatchHandler* hndlr) { - CALL("RobSubstitution::unifyArgs"); ASS_EQ(t1->functor(),t2->functor()); TermList t1TL(t1); @@ -61,7 +58,6 @@ bool RobSubstitution::unifyArgs(Term* t1,int index1, Term* t2, int index2, Misma bool RobSubstitution::match(TermList base,int baseIndex, TermList instance, int instanceIndex) { - CALL("RobSubstitution::match(TermList...)"); return match(TermSpec(base,baseIndex), TermSpec(instance,instanceIndex)); } /** @@ -72,7 +68,6 @@ bool RobSubstitution::match(TermList base,int baseIndex, bool RobSubstitution::matchArgs(Term* base,int baseIndex, Term* instance, int instanceIndex) { - CALL("RobSubstitution::match(Literal*...)"); ASS_EQ(base->functor(),instance->functor()); TermList baseTL(base); @@ -91,8 +86,6 @@ bool RobSubstitution::matchArgs(Term* base,int baseIndex, */ void RobSubstitution::denormalize(const Renaming& normalizer, int normalIndex, int denormalizedIndex) { - CALL("RobSubstitution::denormalize"); - VirtualIterator nit=normalizer.items(); while(nit.hasNext()) { Renaming::Item itm=nit.next(); @@ -105,7 +98,6 @@ void RobSubstitution::denormalize(const Renaming& normalizer, int normalIndex, i bool RobSubstitution::isUnbound(VarSpec v) const { - CALL("RobSubstitution::isUnbound"); for(;;) { TermSpec binding; bool found=_bank.find(v,binding); @@ -146,7 +138,6 @@ TermList RobSubstitution::getSpecialVarTop(unsigned specialVar) const */ RobSubstitution::TermSpec RobSubstitution::derefBound(TermSpec t) const { - CALL("RobSubstitution::derefBound"); if(t.term.isTerm() || t.term.isVSpecialVar()) { return t; } @@ -171,7 +162,6 @@ RobSubstitution::TermSpec RobSubstitution::derefBound(TermSpec t) const */ RobSubstitution::TermSpec RobSubstitution::deref(VarSpec v) const { - CALL("RobSubstitution::deref"); for(;;) { TermSpec binding; bool found=_bank.find(v,binding); @@ -190,7 +180,6 @@ RobSubstitution::TermSpec RobSubstitution::deref(VarSpec v) const void RobSubstitution::bind(const VarSpec& v, const TermSpec& b) { - CALL("RobSubstitution::bind"); ASSERT_VALID(b.term); //Aux terms don't contain special variables, ergo //should be shared. @@ -205,8 +194,6 @@ void RobSubstitution::bind(const VarSpec& v, const TermSpec& b) void RobSubstitution::addToConstraints(const VarSpec& v1, const VarSpec& v2, MismatchHandler* hndlr) { - CALL("RobSubstitution::addToConstraints"); - Term* t1 = _funcSubtermMap->get(v1.var); Term* t2 = _funcSubtermMap->get(v2.var); @@ -228,7 +215,6 @@ void RobSubstitution::addToConstraints(const VarSpec& v1, const VarSpec& v2, Mis void RobSubstitution::bindVar(const VarSpec& var, const VarSpec& to) { - CALL("RobSubstitution::bindVar"); ASS_NEQ(var,to); bind(var,TermSpec(to)); @@ -236,7 +222,6 @@ void RobSubstitution::bindVar(const VarSpec& var, const VarSpec& to) RobSubstitution::VarSpec RobSubstitution::root(VarSpec v) const { - CALL("RobSubstitution::root"); for(;;) { TermSpec binding; bool found=_bank.find(v,binding); @@ -304,8 +289,6 @@ bool RobSubstitution::occurs(VarSpec vs, TermSpec ts) bool RobSubstitution::unify(TermSpec t1, TermSpec t2,MismatchHandler* hndlr) { - CALL("RobSubstitution::unify/2"); - if(t1.sameTermContent(t2)) { return true; } @@ -469,8 +452,6 @@ bool RobSubstitution::unify(TermSpec t1, TermSpec t2,MismatchHandler* hndlr) */ bool RobSubstitution::match(TermSpec base, TermSpec instance) { - CALL("RobSubstitution::match(TermSpec...)"); - if(base.sameTermContent(instance)) { return true; } @@ -569,7 +550,6 @@ bool RobSubstitution::match(TermSpec base, TermSpec instance) Literal* RobSubstitution::apply(Literal* lit, int index) const { - CALL("RobSubstitution::apply(Literal*...)"); static DArray ts(32); if (lit->ground()) { @@ -592,8 +572,6 @@ Literal* RobSubstitution::apply(Literal* lit, int index) const TermList RobSubstitution::apply(TermList trm, int index) const { - CALL("RobSubstitution::apply(TermList...)"); - static Stack toDo(8); static Stack toDoIndex(8); static Stack terms(8); @@ -686,8 +664,6 @@ TermList RobSubstitution::apply(TermList trm, int index) const size_t RobSubstitution::getApplicationResultWeight(TermList trm, int index) const { - CALL("RobSubstitution::getApplicationResultWeight"); - static Stack toDo(8); static Stack toDoIndex(8); static Stack terms(8); @@ -778,7 +754,6 @@ size_t RobSubstitution::getApplicationResultWeight(TermList trm, int index) cons size_t RobSubstitution::getApplicationResultWeight(Literal* lit, int index) const { - CALL("RobSubstitution::getApplicationResultWeight"); static DArray ts(32); if (lit->ground()) { @@ -824,8 +799,6 @@ template SubstIterator RobSubstitution::getAssocIterator(RobSubstitution* subst, Literal* l1, int l1Index, Literal* l2, int l2Index, bool complementary) { - CALL("RobSubstitution::getAssocIterator"); - if( !Literal::headersMatch(l1,l2,complementary) ) { return SubstIterator::getEmpty(); } @@ -911,7 +884,6 @@ class RobSubstitution::AssocIterator: public IteratorCore { ASS_EQ(_l1->arity(), 2); } ~AssocIterator() { - CALL("RobSubstitution::AssocIterator::~AssocIterator"); if (_state != FINISHED && _state != FIRST) { backtrack(_bdataMain); backtrack(_bdataEqAssoc); @@ -920,8 +892,6 @@ class RobSubstitution::AssocIterator: public IteratorCore { ASS(_bdataEqAssoc.isEmpty()); } bool hasNext() { - CALL("RobSubstitution::AssocIterator::hasNext"); - if (_state == FINISHED) { return false; } @@ -985,8 +955,6 @@ class RobSubstitution::AssocIterator: public IteratorCore { } private: void backtrack(BacktrackData &_bdata) { - CALL("RobSubstitution::AssocIterator::backtrack"); - ASS_EQ(&_bdata, &_subst->bdGet()); _subst->bdDone(); _bdata.backtrack(); diff --git a/Kernel/RobSubstitution.hpp b/Kernel/RobSubstitution.hpp index cbf8215c3..1cde7d4c3 100644 --- a/Kernel/RobSubstitution.hpp +++ b/Kernel/RobSubstitution.hpp @@ -245,7 +245,6 @@ class RobSubstitution VarSpec getVarSpec(TermList tl, int index) const { - CALL("RobSubstitution::getVarSpec"); ASS(tl.isVar()); index = tl.isSpecialVar() ? SPECIAL_INDEX : index; return VarSpec(tl.var(), index); diff --git a/Kernel/SKIKBO.cpp b/Kernel/SKIKBO.cpp index 177a8b9c5..62e3934b8 100644 --- a/Kernel/SKIKBO.cpp +++ b/Kernel/SKIKBO.cpp @@ -15,7 +15,6 @@ */ #include -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" @@ -128,8 +127,6 @@ Ordering::Result SKIKBO::State::result(ArgsIt_ptr aai1, ArgsIt_ptr aai2) Ordering::Result SKIKBO::State::innerResult(ArgsIt_ptr aai1, ArgsIt_ptr aai2) { - CALL("KBO::State::innerResult"); - ASS(!_kbo.sameCategoryHeads(aai1, aai2) || aai1->headNum() != aai2->headNum()); if(_posNum>0 && _negNum>0) { @@ -159,7 +156,6 @@ Ordering::Result SKIKBO::State::innerResult(ArgsIt_ptr aai1, ArgsIt_ptr aai2) void SKIKBO::State::recordVariable(unsigned var, int coef) { - CALL("KBO::State::recordVariable"); ASS(coef==1 || coef==-1); int* pnum; @@ -182,8 +178,6 @@ void SKIKBO::State::recordVariable(unsigned var, int coef) void SKIKBO::State::traverse(ArgsIt_ptr aai,int coef) { - CALL("KBO::State::traverse(TermList...)"); - if(!aai->varHead()){ _weightDiff+=_kbo.symbolWeight(aai->head().term())*coef; } else { @@ -216,7 +210,6 @@ void SKIKBO::State::traverse(ArgsIt_ptr aai,int coef) void SKIKBO::State::traverse(ArgsIt_ptr aat1, ArgsIt_ptr aat2) { - CALL("KBO::State::traverse"); ASS(aat1->headNum()==aat2->headNum()); ASS(aat1->hasNext() || aat2->hasNext()); ASS_EQ(_lexResult, EQUAL); @@ -299,8 +292,6 @@ SKIKBO::SKIKBO(Problem& prb, const Options& opt, bool basic_hol) : PrecedenceOrdering(prb, opt), _weights(KboWeightMap::dflt()) { - CALL("SKIKBO::SKIKBO"); - _state=new State(this); _basic_hol = basic_hol; } @@ -324,14 +315,11 @@ SKIKBO::SKIKBO( SKIKBO::~SKIKBO() { - CALL("SKIKBO::~SKIKBO"); delete _state; } bool SKIKBO::safe(Term* t1, Term* t2) const { - CALL("SKIKBO::safe"); - static TermStack toBeChecked; toBeChecked.push(TermList(t1)); toBeChecked.push(TermList(t2)); @@ -388,8 +376,6 @@ bool SKIKBO::safe(Term* t1, Term* t2) const /** A linear time approximation of the actual variable condition from the paper */ bool SKIKBO::varConditionHolds(DHMultiset& tlTerms1, DHMultiset& tlTerms2) const { - CALL("SKIKBO::varConditionHolds"); - DHMultiset unmatchedTlTerms1; unmatchedTlTerms1.loadFromIterator(DHMultiset::Iterator(tlTerms1)); @@ -416,8 +402,6 @@ bool SKIKBO::varConditionHolds(DHMultiset& tlTerms1, DHMultiset& t SKIKBO::VarCondRes SKIKBO::compareVariables(TermList tl1, TermList tl2) const { - CALL("SKIKBO::compareVariables"); - VarCondRes vcr = BOTH; DHMultiset tl1TopLevelVarLikeTerms; @@ -556,8 +540,6 @@ SKIKBO::VarCondRes SKIKBO::compareVariables(TermList tl1, TermList tl2) const unsigned SKIKBO::getMaxRedLength(TermList t) const { - CALL("SKIKBO::getMaxRedLength"); - if(t.isVar()){ return 0; } int tRedLen = t.term()->maxRedLength(); @@ -572,8 +554,6 @@ unsigned SKIKBO::getMaxRedLength(TermList t) const Ordering::Result SKIKBO::compare(TermList tl1, TermList tl2) const { - CALL("SKIKBO::compare(TermList)"); - //bool print = false; if(tl1==tl2) { return EQUAL; @@ -662,9 +642,7 @@ int SKIKBO::symbolWeight(Term* t) const unsigned SKIKBO::maximumReductionLength(Term* term) - -{ CALL("SKIKBO::maximumReductionLength"); - +{ static Stack toEvaluate; static TermStack args; TermList head; @@ -701,8 +679,6 @@ unsigned SKIKBO::maximumReductionLength(Term* term) TermList SKIKBO::reduce(TermStack& args, TermList& head) { - CALL("SKIKBO::reduce"); - ASS(head.isTerm()); Signature::Combinator c = AH::getComb(head); ASS(c != Signature::NOT_COMB); diff --git a/Kernel/Signature.cpp b/Kernel/Signature.cpp index 13ae9247c..0de388007 100644 --- a/Kernel/Signature.cpp +++ b/Kernel/Signature.cpp @@ -62,7 +62,6 @@ Signature::Symbol::Symbol(const vstring& nm, unsigned arity, bool interpreted, b _prox(NOT_PROXY), _comb(NOT_COMB) { - CALL("Signature::Symbol::Symbol"); ASS(!stringConstant || arity==0); if (!stringConstant && !numericConstant && !overflownConstant && @@ -79,8 +78,6 @@ Signature::Symbol::Symbol(const vstring& nm, unsigned arity, bool interpreted, b */ void Signature::Symbol::destroyFnSymbol() { - CALL("Signature::Symbol::destroyFnSymbol"); - if (integerConstant()) { delete static_cast(this); } @@ -103,8 +100,6 @@ void Signature::Symbol::destroyFnSymbol() */ void Signature::Symbol::destroyPredSymbol() { - CALL("Signature::Symbol::destroyPredSymbol"); - if (interpreted()) { delete static_cast(this); } @@ -115,7 +110,6 @@ void Signature::Symbol::destroyPredSymbol() void Signature::Symbol::destroyTypeConSymbol() { - CALL("Signature::Symbol::destroyTypeConSymbol"); ASS(!interpreted()); delete this; @@ -131,8 +125,6 @@ void Signature::Symbol::destroyTypeConSymbol() */ void Signature::Symbol::addToDistinctGroup(unsigned group,unsigned this_number) { - CALL("Signature::Symbol::addToDistinctGroup"); - ASS_EQ(arity(), 0); ASS(!List::member(group, _distinctGroups)) @@ -159,7 +151,6 @@ void Signature::Symbol::addToDistinctGroup(unsigned group,unsigned this_number) */ void Signature::Symbol::setType(OperatorType* type) { - CALL("Signature::Symbol::setType"); ASS_REP(!_type, _type->toString()); // this is copied out to the Symbol for convenience @@ -174,7 +165,6 @@ void Signature::Symbol::setType(OperatorType* type) */ void Signature::Symbol::forceType(OperatorType* type) { - CALL("Signature::Symbol::forceType"); if(_type){ delete _type; } _type = type; } @@ -187,8 +177,6 @@ void Signature::Symbol::forceType(OperatorType* type) */ OperatorType* Signature::Symbol::fnType() const { - CALL("Signature::Symbol::fnType"); - if (!_type) { TermList def = AtomicSort::defaultSort(); _type = OperatorType::getFunctionTypeUniformRange(arity(), def, def); @@ -204,8 +192,6 @@ OperatorType* Signature::Symbol::fnType() const */ OperatorType* Signature::Symbol::typeConType() const { - CALL("Signature::Symbol::typeConType"); - if (!_type) { _type = OperatorType::getTypeConType(arity()); } @@ -220,8 +206,6 @@ OperatorType* Signature::Symbol::typeConType() const */ OperatorType* Signature::Symbol::predType() const { - CALL("Signature::Symbol::predType"); - if (!_type) { TermList def = AtomicSort::defaultSort(); _type = OperatorType::getPredicateTypeUniformRange(arity(), def); @@ -252,7 +236,6 @@ Signature::Signature (): _appFun(UINT_MAX), _termAlgebras() { - CALL("Signature::Signature"); ALWAYS(createDistinctGroup() == STRING_DISTINCT_GROUP); } // Signature::Signature @@ -263,7 +246,6 @@ Signature::Signature (): */ void Signature::addEquality() { - CALL("Signature::addEquality"); // initialize equality addInterpretedPredicate(Theory::EQUAL, OperatorType::getPredicateType(2), "="); ASS_EQ(predicateName(0), "="); //equality must have number 0 @@ -295,8 +277,6 @@ Signature::~Signature () */ unsigned Signature::addIntegerConstant(const vstring& number,bool defaultSort) { - CALL("Signature::addIntegerConstant(vstring)"); - IntegerConstantType value(number); if (!defaultSort) { return addIntegerConstant(value); @@ -329,8 +309,6 @@ unsigned Signature::addIntegerConstant(const vstring& number,bool defaultSort) */ unsigned Signature::addIntegerConstant(const IntegerConstantType& value) { - CALL("Signature::addIntegerConstant"); - vstring key = value.toString() + "_n"; unsigned result; if (_funNames.find(key, result)) { @@ -355,8 +333,6 @@ unsigned Signature::addIntegerConstant(const IntegerConstantType& value) */ unsigned Signature::addRationalConstant(const vstring& numerator, const vstring& denominator,bool defaultSort) { - CALL("Signature::addRationalConstant(vstring,vstring)"); - RationalConstantType value(numerator, denominator); if (!defaultSort) { return addRationalConstant(value); @@ -383,8 +359,6 @@ unsigned Signature::addRationalConstant(const vstring& numerator, const vstring& unsigned Signature::addRationalConstant(const RationalConstantType& value) { - CALL("Signature::addRationalConstant"); - vstring key = value.toString() + "_q"; unsigned result; if (_funNames.find(key, result)) { @@ -405,8 +379,6 @@ unsigned Signature::addRationalConstant(const RationalConstantType& value) */ unsigned Signature::addRealConstant(const vstring& number,bool defaultSort) { - CALL("Signature::addRealConstant(vstring)"); - RealConstantType value(number); if (!defaultSort) { return addRealConstant(value); @@ -431,8 +403,6 @@ unsigned Signature::addRealConstant(const vstring& number,bool defaultSort) unsigned Signature::addRealConstant(const RealConstantType& value) { - CALL("Signature::addRealConstant"); - vstring key = value.toString() + "_r"; unsigned result; if (_funNames.find(key, result)) { @@ -450,7 +420,6 @@ unsigned Signature::addRealConstant(const RealConstantType& value) */ unsigned Signature::addInterpretedFunction(Interpretation interpretation, OperatorType* type, const vstring& name) { - CALL("Signature::addInterpretedFunction(Interpretation,OperatorType*,const vstring&)"); ASS(Theory::isFunction(interpretation)); Theory::MonomorphisedInterpretation mi = std::make_pair(interpretation,type); @@ -484,7 +453,6 @@ unsigned Signature::addInterpretedFunction(Interpretation interpretation, Operat */ unsigned Signature::addInterpretedPredicate(Interpretation interpretation, OperatorType* type, const vstring& name) { - CALL("Signature::addInterpretedPredicate(Interpretation,OperatorType*,const vstring&)"); ASS(!Theory::isFunction(interpretation)); // cout << "addInterpretedPredicate " << (type ? type->toString() : "nullptr") << " " << name << endl; @@ -526,8 +494,6 @@ unsigned Signature::addInterpretedPredicate(Interpretation interpretation, Opera */ unsigned Signature::getInterpretingSymbol(Interpretation interp, OperatorType* type) { - CALL("Signature::getInterpretingSymbol(Interpretation,OperatorType*)"); - Theory::MonomorphisedInterpretation mi = std::make_pair(interp,type); unsigned res; @@ -565,8 +531,6 @@ unsigned Signature::getInterpretingSymbol(Interpretation interp, OperatorType* t const vstring& Signature::functionName(int number) { - CALL("Signature::functionName"); - // it is safe to reuse "$true" and "$false" for constants // because the user cannot define constants with these names herself // and the formula, obtained by toString() with "$true" or "$false" @@ -587,8 +551,6 @@ const vstring& Signature::functionName(int number) */ bool Signature::functionExists(const vstring& name,unsigned arity) const { - CALL("Signature::functionExists"); - return _funNames.find(key(name, arity)); } @@ -597,8 +559,6 @@ bool Signature::functionExists(const vstring& name,unsigned arity) const */ bool Signature::predicateExists(const vstring& name,unsigned arity) const { - CALL("Signature::predicateExists"); - return _predNames.find(key(name, arity)); } @@ -607,22 +567,17 @@ bool Signature::predicateExists(const vstring& name,unsigned arity) const */ bool Signature::typeConExists(const vstring& name,unsigned arity) const { - CALL("Signature::typeConExists"); - return _typeConNames.find(key(name, arity)); } unsigned Signature::getFunctionNumber(const vstring& name, unsigned arity) const { - CALL("Signature::getFunctionNumber"); - ASS(_funNames.find(key(name, arity))); return _funNames.get(key(name, arity)); } bool Signature::tryGetFunctionNumber(const vstring& name, unsigned arity, unsigned& out) const { - CALL("Signature::tryGetFunctionNumber"); auto* value = _funNames.getPtr(key(name, arity)); if (value != NULL) { out = *value; @@ -634,7 +589,6 @@ bool Signature::tryGetFunctionNumber(const vstring& name, unsigned arity, unsign bool Signature::tryGetPredicateNumber(const vstring& name, unsigned arity, unsigned& out) const { - CALL("Signature::tryGetPredicateNumber"); auto* value = _predNames.getPtr(key(name, arity)); if (value != NULL) { out = *value; @@ -647,8 +601,6 @@ bool Signature::tryGetPredicateNumber(const vstring& name, unsigned arity, unsig unsigned Signature::getPredicateNumber(const vstring& name, unsigned arity) const { - CALL("Signature::getPredicateNumber"); - ASS(_predNames.find(key(name, arity))); return _predNames.get(key(name, arity)); } @@ -668,8 +620,6 @@ unsigned Signature::addFunction (const vstring& name, bool& added, bool overflowConstant) { - CALL("Signature::addFunction"); - vstring symbolKey = key(name,arity); unsigned result; if (_funNames.find(symbolKey,result)) { @@ -704,8 +654,6 @@ unsigned Signature::addFunction (const vstring& name, */ unsigned Signature::addStringConstant(const vstring& name) { - CALL("Signature::addStringConstant"); - vstring symbolKey = name + "_c"; unsigned result; if (_funNames.find(symbolKey,result)) { @@ -725,8 +673,6 @@ unsigned Signature::addStringConstant(const vstring& name) unsigned Signature::getApp() { - CALL("Signature::getApp"); - bool added = false; unsigned app = addFunction("vAPP", 4, added); if(added){ @@ -742,8 +688,6 @@ unsigned Signature::getApp() } unsigned Signature::getDiff(){ - CALL("Signature::getDiff"); - bool added = false; unsigned diff = addFunction("diff",2, added); if(added){ @@ -759,8 +703,6 @@ unsigned Signature::getDiff(){ unsigned Signature::getChoice(){ - CALL("Signature::getChoice"); - bool added = false; unsigned choice = addFunction("vEPSILON",1, added); if(added){ @@ -775,7 +717,6 @@ unsigned Signature::getChoice(){ } void Signature::incrementFormulaCount(Term* t){ - CALL("Signature::incrementFormulaCount"); ASS(SortHelper::getResultSort(t) == AtomicSort::boolSort()); if(_formulaCounts.find(t)){ @@ -789,7 +730,6 @@ void Signature::incrementFormulaCount(Term* t){ } void Signature::decrementFormulaCount(Term* t){ - CALL("Signature::incrementFormulaCount"); ASS(SortHelper::getResultSort(t) == AtomicSort::boolSort()); ASS(_formulaCounts.find(t)) @@ -800,7 +740,6 @@ void Signature::decrementFormulaCount(Term* t){ } void Signature::formulaNamed(Term* t){ - CALL("Signature::formulaNamed"); ASS(SortHelper::getResultSort(t) == AtomicSort::boolSort()); ASS(_formulaCounts.find(t)); @@ -808,8 +747,6 @@ void Signature::formulaNamed(Term* t){ } unsigned Signature::formulaCount(Term* t){ - CALL("Signature::formulaCount"); - if(_formulaCounts.find(t)){ return _formulaCounts.get(t); } @@ -857,8 +794,6 @@ unsigned Signature::addPredicate (const vstring& name, unsigned arity, bool& added) { - CALL("Signature::addPredicate"); - vstring symbolKey = key(name,arity); unsigned result; if (_predNames.find(symbolKey,result)) { @@ -892,14 +827,12 @@ unsigned Signature::addPredicate (const vstring& name, */ unsigned Signature::addNamePredicate(unsigned arity) { - CALL("Signature::addNamePredicate"); return addFreshPredicate(arity,"sP"); } // addNamePredicate unsigned Signature::addNameFunction(unsigned arity) { - CALL("Signature::addNameFunction"); return addFreshFunction(arity,"sP"); } // addNamePredicate /** @@ -910,8 +843,6 @@ unsigned Signature::addNameFunction(unsigned arity) */ unsigned Signature::addFreshFunction(unsigned arity, const char* prefix, const char* suffix) { - CALL("Signature::addFreshFunction"); - vstring pref(prefix); vstring suf(suffix ? vstring("_")+suffix : ""); bool added; @@ -940,8 +871,6 @@ unsigned Signature::addFreshFunction(unsigned arity, const char* prefix, const c */ unsigned Signature::addFreshTypeCon(unsigned arity, const char* prefix, const char* suffix) { - CALL("Signature::addFreshTypeCon"); - vstring pref(prefix); vstring suf(suffix ? vstring("_")+suffix : ""); bool added; @@ -968,8 +897,6 @@ unsigned Signature::addFreshTypeCon(unsigned arity, const char* prefix, const ch */ unsigned Signature::addFreshPredicate(unsigned arity, const char* prefix, const char* suffix) { - CALL("Signature::addFreshPredicate"); - vstring pref(prefix); vstring suf(suffix ? vstring("_")+suffix : ""); bool added = false; @@ -999,8 +926,6 @@ unsigned Signature::addFreshPredicate(unsigned arity, const char* prefix, const */ unsigned Signature::addSkolemFunction (unsigned arity, const char* suffix) { - CALL("Signature::addSkolemFunction"); - unsigned f = addFreshFunction(arity, "sK", suffix); getFunction(f)->markSkolem(); @@ -1018,8 +943,6 @@ unsigned Signature::addSkolemFunction (unsigned arity, const char* suffix) */ unsigned Signature::addSkolemTypeCon (unsigned arity, const char* suffix) { - CALL("Signature::addSkolemTypeCon"); - unsigned tc = addFreshTypeCon(arity, "sK", suffix); getTypeCon(tc)->markSkolem(); @@ -1038,8 +961,6 @@ unsigned Signature::addSkolemTypeCon (unsigned arity, const char* suffix) */ unsigned Signature::addSkolemPredicate(unsigned arity, const char* suffix) { - CALL("Signature::addSkolemPredicate"); - unsigned p = addFreshPredicate(arity, "sK", suffix); getPredicate(p)->markSkolem(); @@ -1083,8 +1004,6 @@ void Signature::Symbol::addColor(Color color) */ unsigned Signature::createDistinctGroup(Unit* premise) { - CALL("Signature::createDistinctGroup"); - unsigned res = _distinctGroupPremises.size(); _distinctGroupPremises.push(premise); // DistinctGroupMember stack = ; @@ -1097,8 +1016,6 @@ unsigned Signature::createDistinctGroup(Unit* premise) */ Unit* Signature::getDistinctGroupPremise(unsigned group) { - CALL("Signature::getDistinctGroupPremise"); - return _distinctGroupPremises[group]; } @@ -1109,16 +1026,12 @@ Unit* Signature::getDistinctGroupPremise(unsigned group) */ void Signature::addToDistinctGroup(unsigned constantSymbol, unsigned groupId) { - CALL("Signature::addToDistinctGroup"); - Symbol* sym = getFunction(constantSymbol); sym->addToDistinctGroup(groupId,constantSymbol); } bool Signature::isProtectedName(vstring name) { - CALL("Signature::isProtectedName"); - if (name=="$distinct") { //TODO: remove this hack once we properly support the $distinct predicate return true; @@ -1162,7 +1075,6 @@ bool Signature::isProtectedName(vstring name) */ bool Signature::symbolNeedsQuoting(vstring name, bool interpreted, unsigned arity) { - CALL("Signature::symbolNeedsQuoting"); ASS_G(name.length(),0); //we don't want to quote these type constructors, but we @@ -1209,8 +1121,6 @@ bool Signature::symbolNeedsQuoting(vstring name, bool interpreted, unsigned arit TermAlgebraConstructor* Signature::getTermAlgebraConstructor(unsigned functor) { - CALL("Signature::getTermAlgebraConstructor"); - if (getFunction(functor)->termAlgebraCons()) { TermAlgebra *ta = _termAlgebras.get(getFunction(functor)->fnType()->result().term()->functor()); if (ta) { diff --git a/Kernel/Signature.hpp b/Kernel/Signature.hpp index ff3000771..0dd967075 100644 --- a/Kernel/Signature.hpp +++ b/Kernel/Signature.hpp @@ -323,7 +323,6 @@ class Signature InterpretedSymbol(const vstring& nm, Interpretation interp) : Symbol(nm, Theory::getArity(interp), true), _interp(interp) { - CALL("InterpretedSymbol"); } CLASS_NAME(Signature::InterpretedSymbol); @@ -345,8 +344,6 @@ class Signature IntegerSymbol(const IntegerConstantType& val) : Symbol(val.toString(), 0, true), _intValue(val) { - CALL("IntegerSymbol"); - setType(OperatorType::getConstantsType(AtomicSort::intSort())); } CLASS_NAME(Signature::IntegerSymbol); @@ -365,8 +362,6 @@ class Signature RationalSymbol(const RationalConstantType& val) : Symbol(val.toString(), 0, true), _ratValue(val) { - CALL("RationalSymbol"); - setType(OperatorType::getConstantsType(AtomicSort::rationalSort())); } CLASS_NAME(Signature::RationalSymbol); @@ -385,8 +380,6 @@ class Signature RealSymbol(const RealConstantType& val) : Symbol((env.options->proof() == Shell::Options::Proof::PROOFCHECK) ? "$to_real("+val.toString()+")" : val.toNiceString(), 0, true), _realValue(val) { - CALL("RealSymbol"); - setType(OperatorType::getConstantsType(AtomicSort::realSort())); } CLASS_NAME(Signature::RealSymbol); @@ -457,7 +450,6 @@ class Signature unsigned addInterpretedFunction(Interpretation itp, OperatorType* type, const vstring& name); unsigned addInterpretedFunction(Interpretation itp, const vstring& name) { - CALL("Signature::addInterpretedFunction(Interpretation,const vstring&)"); ASS(!Theory::isPolymorphic(itp)); return addInterpretedFunction(itp,Theory::getNonpolymorphicOperatorType(itp),name); } @@ -465,7 +457,6 @@ class Signature unsigned addInterpretedPredicate(Interpretation itp, OperatorType* type, const vstring& name); unsigned addInterpretedPredicate(Interpretation itp, const vstring& name) { - CALL("Signature::addInterpretedPredicate(Interpretation,const vstring&)"); ASS(!Theory::isPolymorphic(itp)); return addInterpretedPredicate(itp,Theory::getNonpolymorphicOperatorType(itp),name); } @@ -473,19 +464,16 @@ class Signature unsigned getInterpretingSymbol(Interpretation interp, OperatorType* type); unsigned getInterpretingSymbol(Interpretation interp) { - CALL("Signature::getInterpretingSymbol(Interpretation)"); ASS(!Theory::isPolymorphic(interp)); return getInterpretingSymbol(interp,Theory::getNonpolymorphicOperatorType(interp)); } /** Return true iff there is a symbol interpreted by Interpretation @b interp */ bool haveInterpretingSymbol(Interpretation interp, OperatorType* type) const { - CALL("Signature::haveInterpretingSymbol(Interpretation, OperatorType*)"); return _iSymbols.find(std::make_pair(interp,type)); } bool haveInterpretingSymbol(Interpretation interp) { - CALL("Signature::haveInterpretingSymbol(Interpretation)"); ASS(!Theory::isPolymorphic(interp)); return haveInterpretingSymbol(interp,Theory::getNonpolymorphicOperatorType(interp)); } @@ -505,19 +493,16 @@ class Signature /** return the arity of a function with a given number */ const unsigned functionArity(int number) { - CALL("Signature::functionArity"); return _funs[number]->arity(); } /** return the arity of a predicate with a given number */ const unsigned predicateArity(int number) { - CALL("Signature::predicateArity"); return _preds[number]->arity(); } const unsigned typeConArity(int number) { - CALL("Signature::typeConArity"); return _typeCons[number]->arity(); } @@ -676,8 +661,6 @@ class Signature } unsigned getDefaultSort(){ - CALL("Signature::getDefaultSort"); - bool added = false; unsigned individualSort = addTypeCon("$i",0, added); if(added){ @@ -687,8 +670,6 @@ class Signature } unsigned getBoolSort(){ - CALL("Signature::getBoolSort"); - bool added = false; unsigned boolSort = addTypeCon("$o",0, added); if(added){ diff --git a/Kernel/SortHelper.cpp b/Kernel/SortHelper.cpp index e8be64d5a..09f9c6033 100644 --- a/Kernel/SortHelper.cpp +++ b/Kernel/SortHelper.cpp @@ -36,8 +36,6 @@ using namespace Kernel; */ OperatorType* SortHelper::getType(Term* t) { - CALL("SortHelper::getType(Term*)"); - if (t->isLiteral()) { return env.signature->getPredicate(t->functor())->predType(); } else if (t->isSort()) { @@ -57,8 +55,6 @@ OperatorType* SortHelper::getType(Term* t) */ void SortHelper::getTypeSub(const Term* t, Substitution& subst) { - CALL("SortHelper::getTypeSub(Term*)"); - TermList* typeArg; OperatorType* ot = getType(const_cast(t)); //sym->fnType(); unsigned typeArgsArity = ot->numTypeArguments(); @@ -84,7 +80,6 @@ void SortHelper::getTypeSub(const Term* t, Substitution& subst) */ TermList SortHelper::getResultSort(const Term* t) { - CALL("SortHelper::getResultSort(Term*)"); ASS(!t->isSpecial()); ASS(!t->isLiteral()); @@ -102,7 +97,6 @@ TermList SortHelper::getResultSort(const Term* t) TermList SortHelper::getResultSortMono(const Term* t) { - CALL("SortHelper::getResultSortMono(Term*)"); ASS(!t->isSpecial()); ASS(!t->isLiteral()); @@ -117,7 +111,6 @@ TermList SortHelper::getResultSortMono(const Term* t) */ bool SortHelper::tryGetResultSort(const Term* t, TermList& result) { - CALL("tryGetResultSort(Term*,unsigned&)"); ASS(!t->isLiteral()); TermList masterVar; @@ -126,7 +119,6 @@ bool SortHelper::tryGetResultSort(const Term* t, TermList& result) bool SortHelper::tryGetResultSort(const TermList t, TermList& result) { - CALL("tryGetResultSort(TermList,unsigned&)"); if (t.isVar()) { return false; } @@ -138,8 +130,6 @@ bool SortHelper::tryGetResultSort(const TermList t, TermList& result) */ TermList SortHelper::getResultSort(TermList t, DHMap& varSorts) { - CALL("SortHelper::getResultSort"); - TermList res; TermList masterVar; if (!getResultSortOrMasterVariable(t, res, masterVar)) { @@ -156,8 +146,6 @@ TermList SortHelper::getResultSort(TermList t, DHMap& varSort */ bool SortHelper::getResultSortOrMasterVariable(const Term* t, TermList& resultSort, TermList& resultVar) { - CALL("SortHelper::getResultSortOrMasterVariable"); - if(t->isSort()){ resultSort = AtomicSort::superSort(); return true; @@ -198,8 +186,6 @@ bool SortHelper::getResultSortOrMasterVariable(const Term* t, TermList& resultSo */ bool SortHelper::getResultSortOrMasterVariable(const TermList t, TermList& resultSort, TermList& resultVar) { - CALL("SortHelper::getResultSortOrMasterVariable"); - if (t.isVar()) { resultVar = t; return false; @@ -212,7 +198,6 @@ bool SortHelper::getResultSortOrMasterVariable(const TermList t, TermList& resul */ TermList SortHelper::getArgSort(Term* t, unsigned argIndex) { - CALL("SortHelper::getArgSort(Term*,unsigned)"); ASS_L(argIndex, t->arity()); if(t->isSort()){ @@ -240,7 +225,6 @@ TermList SortHelper::getTermArgSort(Term* t, unsigned n) TermList SortHelper::getEqualityArgumentSort(const Literal* lit) { - CALL("SortHelper::getEqualityArgumentSort"); ASS(lit->isEquality()); if (lit->isTwoVarEquality()) { @@ -264,8 +248,6 @@ TermList SortHelper::getEqualityArgumentSort(const Literal* lit) */ TermList SortHelper::getTermSort(TermList trm, Literal* lit) { - CALL("SortHelper::getTermSort"); - if (trm.isTerm()) { return getResultSort(trm.term()); } @@ -283,8 +265,6 @@ TermList SortHelper::getTermSort(TermList trm, Literal* lit) */ TermList SortHelper::getVariableSort(TermList var, Term* t) { - CALL("SortHelper::getVariableSort(TermList,Term*)"); - TermList res; ALWAYS(tryGetVariableSortTerm(var, t, res, true)); return res; @@ -297,8 +277,6 @@ TermList SortHelper::getVariableSort(TermList var, Term* t) */ bool SortHelper::tryGetVariableSort(unsigned var, Formula* f, TermList& res) { - CALL("SortHelper::tryGetVariableSort(unsigned,Formula*,unsigned&)"); - TermList varTerm(var, false); SubformulaIterator sfit(f); @@ -349,8 +327,6 @@ bool SortHelper::tryGetVariableSort(unsigned var, Formula* f, TermList& res) */ void SortHelper::collectVariableSortsIter(CollectTask task, DHMap& map, bool ignoreBound) { - CALL("SortHelper::collectVariableSortsIter"); - Stack todo; MultiCounter bound; @@ -655,8 +631,6 @@ void SortHelper::collectVariableSortsIter(CollectTask task, DHMap& map) { - CALL("SortHelper::collectVariableSorts(Term*,...)"); - CollectTask t(term->isSpecial() ? COLLECT_SPECIALTERM : COLLECT_TERM); t.t = term; @@ -670,8 +644,6 @@ void SortHelper::collectVariableSorts(Term* term, DHMap& map) */ void SortHelper::collectVariableSorts(Formula* f, DHMap& map, bool ignoreBound) { - CALL("SortHelper::collectVariableSorts(Formula*,...)"); - CollectTask task(COLLECT_FORMULA); task.f = f; @@ -685,8 +657,6 @@ void SortHelper::collectVariableSorts(Formula* f, DHMap& map, */ void SortHelper::collectVariableSorts(Unit* u, DHMap& map) { - CALL("SortHelper::collectVariableSorts(Unit*,...)"); - if (!u->isClause()) { FormulaUnit* fu = static_cast(u); @@ -712,8 +682,6 @@ void SortHelper::collectVariableSorts(Unit* u, DHMap& map) void SortHelper::normaliseArgSorts(VList* qVars, TermStack& argSorts) { - CALL("SortHelper::normaliseArgSorts/1"); - Substitution subst; unsigned i = 0; while(qVars){ @@ -729,8 +697,6 @@ void SortHelper::normaliseArgSorts(VList* qVars, TermStack& argSorts) void SortHelper::normaliseSort(VList* qVars, TermList& sort) { - CALL("SortHelper::normaliseSort/1"); - Substitution subst; unsigned i = 0; while(qVars){ @@ -744,8 +710,6 @@ void SortHelper::normaliseSort(VList* qVars, TermList& sort) void SortHelper::normaliseArgSorts(TermStack& qVars, TermStack& argSorts) { - CALL("SortHelper::normaliseArgSorts/2"); - Substitution subst; for(unsigned i = 0; i < qVars.size(); i++){ subst.bind(qVars[i].var(), TermList(i, false)); @@ -758,8 +722,6 @@ void SortHelper::normaliseArgSorts(TermStack& qVars, TermStack& argSorts) void SortHelper::normaliseSort(TermStack qVars, TermList& sort) { - CALL("SortHelper::normaliseSort/2"); - Substitution subst; for(unsigned i = 0; i < qVars.size(); i++){ subst.bind(qVars[i].var(), TermList(i, false)); @@ -780,7 +742,6 @@ void SortHelper::normaliseSort(TermStack qVars, TermList& sort) */ bool SortHelper::tryGetVariableSortTerm(TermList var, Term* t0, TermList& result, bool recurseToSubformulas) { - CALL("SortHelper::tryGetVariableSortTerm"); ASS(var.isVar()); NonVariableIterator sit(t0,true); @@ -881,8 +842,6 @@ bool SortHelper::tryGetVariableSortTerm(TermList var, Term* t0, TermList& result */ bool SortHelper::areImmediateSortsValidPoly(Term* t) { - CALL("SortHelper::areImmediateSortsValidPoly"); - ASS(!t->isSuper()); if (t->isLiteral() && static_cast(t)->isEquality()) { @@ -926,8 +885,6 @@ bool SortHelper::areImmediateSortsValidPoly(Term* t) */ bool SortHelper::areImmediateSortsValidMono(Term* t) { - CALL("SortHelper::areImmediateSortsValidMono"); - ASS(!t->isSuper()); if (t->isLiteral() && static_cast(t)->isEquality()) { @@ -968,8 +925,6 @@ bool SortHelper::areImmediateSortsValidMono(Term* t) */ bool SortHelper::allTopLevelArgsAreSorts(AtomicSort* sort) { - CALL("SortHelper::allTopLevelArgsAreSorts"); - for(unsigned i = 0; i < sort->arity(); i++){ TermList arg = *sort->nthArgument(i); if(arg.isVar()){ @@ -984,14 +939,12 @@ bool SortHelper::allTopLevelArgsAreSorts(AtomicSort* sort) TermList SortHelper::getIndexSort(TermList arraySort) { - CALL("SortHelper::getIndexSort"); ASS(arraySort.isArraySort()); return *arraySort.term()->nthArgument(0); } TermList SortHelper::getInnerSort(TermList arraySort) { - CALL("SortHelper::getInnerSort"); ASS(arraySort.isArraySort()); return *arraySort.term()->nthArgument(1); } @@ -1004,8 +957,6 @@ TermList SortHelper::getInnerSort(TermList arraySort) */ bool SortHelper::areSortsValid(Clause* cl) { - CALL("SortHelper::areSortsValid"); - static DHMap varSorts; varSorts.reset(); @@ -1019,7 +970,6 @@ bool SortHelper::areSortsValid(Clause* cl) } bool SortHelper::areSortsValid(Term* t0) { - CALL("SortHelper::areSortsValid"); DHMap varSorts; return areSortsValid(t0, varSorts); } @@ -1033,8 +983,6 @@ bool SortHelper::areSortsValid(Term* t0) */ bool SortHelper::areSortsValid(Term* t0, DHMap& varSorts) { - CALL("SortHelper::areSortsValid"); - NonVariableIterator sit(t0,true); while (sit.hasNext()) { Term* t = sit.next().term(); diff --git a/Kernel/SpassLiteralSelector.cpp b/Kernel/SpassLiteralSelector.cpp index 8be1b9b43..70ee22746 100644 --- a/Kernel/SpassLiteralSelector.cpp +++ b/Kernel/SpassLiteralSelector.cpp @@ -27,8 +27,6 @@ using namespace Kernel; LiteralList* SpassLiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligible) { - CALL("SpassLiteralSelector::getMaximalsInOrder"); - LiteralList* res = LiteralList::empty(); for(int li=((int)eligible)-1; li>=0; li--) { @@ -42,8 +40,6 @@ LiteralList* SpassLiteralSelector::getMaximalsInOrder(Clause* c, unsigned eligib void SpassLiteralSelector::doSelection(Clause* c, unsigned eligible) { - CALL("SpassLiteralSelector::doSelection"); - LiteralList* maximals = LiteralList::empty(); if (_value == IFSEVERALMAXIMAL) { diff --git a/Kernel/SubformulaIterator.cpp b/Kernel/SubformulaIterator.cpp index f32251d39..2671fc77b 100644 --- a/Kernel/SubformulaIterator.cpp +++ b/Kernel/SubformulaIterator.cpp @@ -17,7 +17,6 @@ * @since 06/05/2015 Gothenburg in order to support FOOL, we need to search for formulas inside terms as well */ -#include "Debug/Tracer.hpp" #include "SubformulaIterator.hpp" @@ -105,8 +104,6 @@ SubformulaIterator::SubformulaIterator (FormulaList* ts) */ bool SubformulaIterator::hasNext () { - CALL("SubformulaIterator::hasNext"); - if (_current) { return true; } @@ -241,8 +238,6 @@ bool SubformulaIterator::hasNext () */ Formula* SubformulaIterator::next () { - CALL("SubformulaIterator::next/0"); - int dummy; return next(dummy); } @@ -257,8 +252,6 @@ Formula* SubformulaIterator::next () */ Formula* SubformulaIterator::next (int& resultPolarity) { - CALL("SubformulaIterator::next/1"); - Formula* result = _current; resultPolarity = _currentPolarity; diff --git a/Kernel/SubstHelper.hpp b/Kernel/SubstHelper.hpp index 85ecf1d5c..65edab03c 100644 --- a/Kernel/SubstHelper.hpp +++ b/Kernel/SubstHelper.hpp @@ -43,7 +43,6 @@ class SubstHelper template static TermList apply(TermList t, Applicator& applicator, bool noSharing=false) { - CALL("SubstHelper::apply(TermList...)"); return applyImpl(t, applicator, noSharing); } @@ -61,7 +60,6 @@ class SubstHelper template static Term* apply(Term* t, Applicator& applicator, bool noSharing=false) { - CALL("SubstHelper::apply(Term*...)"); return applyImpl(t, applicator, noSharing); } @@ -79,7 +77,6 @@ class SubstHelper template static Literal* apply(Literal* lit, Applicator& applicator) { - CALL("SubstHelper::apply(Literal*...)"); Literal* subbedLit = static_cast(apply(static_cast(lit),applicator)); if(subbedLit->isTwoVarEquality()){ //either nothing's changed or variant TermList sort = lit->twoVarEqSort(); @@ -106,7 +103,6 @@ class SubstHelper template static Formula* apply(Formula* f, Applicator& applicator) { - CALL("SubstHelper::apply(Formula*...)"); return applyImpl(f, applicator, false); } @@ -141,7 +137,6 @@ class SubstHelper template static Literal* applyToLiteral(Literal* lit, Subst subst) { - CALL("SubstHelper::applyToLiteral"); static DArray ts(32); int arity = lit->arity(); @@ -192,8 +187,6 @@ class SubstHelper */ static bool canBeShared(TermList * terms, size_t len) { - CALL("SubstHelper::anyNonShareable"); - for(unsigned i=0;ishared())) { @@ -243,8 +236,6 @@ struct SpecVarHandler template TermList SubstHelper::applyImpl(TermList trm, Applicator& applicator, bool noSharing) { - CALL("SubstHelper::applyImpl(TermList...)"); - using namespace SubstHelper_Aux; if(trm.isOrdinaryVar()) { @@ -279,8 +270,6 @@ TermList SubstHelper::applyImpl(TermList trm, Applicator& applicator, bool noSha template Term* SubstHelper::applyImpl(Term* trm, Applicator& applicator, bool noSharing) { - CALL("SubstHelper::applyImpl(Term*...)"); - using namespace SubstHelper_Aux; if(trm->isSpecial()) { @@ -465,8 +454,6 @@ Term* SubstHelper::applyImpl(Term* trm, Applicator& applicator, bool noSharing) template Formula* SubstHelper::applyImpl(Formula* f, Applicator& applicator, bool noSharing) { - CALL("SubstHelper::applyImpl(Formula*...)"); - switch (f->connective()) { case LITERAL: { @@ -560,8 +547,6 @@ Formula* SubstHelper::applyImpl(Formula* f, Applicator& applicator, bool noShari template FormulaList* SubstHelper::applyImpl(FormulaList* fs, Applicator& applicator, bool noSharing) { - CALL("SubstHelper::applyImpl(FormulaList*...)"); - if (FormulaList::isEmpty(fs)) { return fs; } diff --git a/Kernel/Substitution.cpp b/Kernel/Substitution.cpp index 6b1d46316..ae7427e40 100644 --- a/Kernel/Substitution.cpp +++ b/Kernel/Substitution.cpp @@ -29,7 +29,6 @@ namespace Kernel */ void Substitution::bind(int v,Term* t) { - CALL("Substitution::bind(int,Term*)"); TermList ts; ts.setTerm(t); bind(v,ts); @@ -47,8 +46,6 @@ void Substitution::rebind(int v,Term* t) */ void Substitution::bind(int v,TermList t) { - CALL("Substitution::bind(int,TermList)"); - ALWAYS(_map.insert(v, t)); } // Substitution::bind @@ -65,15 +62,11 @@ void Substitution::rebind(int v,TermList t) */ void Substitution::unbind(int v) { - CALL("Substitution::unbind"); - ALWAYS(_map.remove(v)); } // Substitution::unbind void Substitution::reset() { - CALL("Substitution::reset"); - _map.reset(); } @@ -98,8 +91,6 @@ TermList Substitution::apply(unsigned var) */ bool Substitution::findBinding(int var, TermList& res) const { - CALL("Substitution::findBinding"); - return _map.find(var, res); } // Substitution::bound diff --git a/Kernel/Term.cpp b/Kernel/Term.cpp index 007457809..5d72f815a 100644 --- a/Kernel/Term.cpp +++ b/Kernel/Term.cpp @@ -32,7 +32,6 @@ constexpr unsigned Term::SPECIAL_FUNCTOR_LOWER_BOUND; void Term::setId(unsigned id) { - CALL("Term::setId"); if (env.options->randomTraversals()) { id += Random::getInteger(1 << 12) << 20; // the twelve most significant bits are randomized } @@ -45,7 +44,6 @@ void Term::setId(unsigned id) */ void* Term::operator new(size_t,unsigned arity, size_t preData) { - CALL("Term::new"); //preData must be a multiple of pointer size to maintain alignment ASS_EQ(preData%sizeof(size_t), 0); @@ -63,7 +61,6 @@ void* Term::operator new(size_t,unsigned arity, size_t preData) */ void Term::destroy () { - CALL("Term::destroy"); ASS(CHECK_LEAKS || ! shared()); size_t sz = sizeof(Term)+_arity*sizeof(TermList)+getPreDataSize(); @@ -77,8 +74,6 @@ void Term::destroy () */ void Term::destroyNonShared() { - CALL("Term::destroyNonShared"); - if (shared()) { return; } @@ -114,8 +109,6 @@ void Term::destroyNonShared() */ bool TermList::isSafe() const { - CALL("TermList::isSafe"); - return isVar() || term()->shared(); } @@ -136,8 +129,6 @@ bool TermList::isSafe() const */ VList* TermList::freeVariables() const { - CALL("TermList::freeVariables"); - FormulaVarIterator fvi(this); VList* result = VList::empty(); VList::FIFO stack(result); @@ -150,7 +141,6 @@ VList* TermList::freeVariables() const bool TermList::isFreeVariable(unsigned var) const { - CALL("TermList::isFreeVariable"); FormulaVarIterator fvi(this); while (fvi.hasNext()) { if (var == fvi.next()) { @@ -251,70 +241,53 @@ unsigned TermList::weight() const bool TermList::isArrowSort() { - CALL("TermList::isArrowSort"); return !isVar() && term()->isSort() && static_cast(term())->isArrowSort(); } bool TermList::isBoolSort() { - CALL("TermList::isBoolSort"); return !isVar() && term()->isSort() && static_cast(term())->isBoolSort(); } bool TermList::isArraySort() { - CALL("TermList::isArraySort"); return !isVar() && term()->isSort() && static_cast(term())->isArraySort(); } bool TermList::isTupleSort() { - CALL("TermList::isTupleSort"); return !isVar() && term()->isSort() && static_cast(term())->isTupleSort(); } bool AtomicSort::isArrowSort() const { - CALL("AtomicSort::isArrowSort"); - return env.signature->isArrowCon(_functor); } bool AtomicSort::isBoolSort() const { - CALL("AtomicSort::isBoolSort"); - return env.signature->isBoolCon(_functor); } bool AtomicSort::isArraySort() const { - CALL("AtomicSort::isArraySort"); - return env.signature->isArrayCon(_functor); } bool AtomicSort::isTupleSort() const { - CALL("AtomicSort::isTupleSort"); - return env.signature->isTupleCon(_functor); } bool TermList::isApplication() const { - CALL("Term::isApplication"); - return !isVar() && term()->isApplication(); } bool Term::isApplication() const { - CALL("Term::isApplication"); - return !isSort() && !isLiteral() && env.signature->isAppFun(_functor); } unsigned Term::numTypeArguments() const { - CALL("Term::numTypeArguments"); ASS(!isSort()); return isSpecial() @@ -326,7 +299,6 @@ unsigned Term::numTypeArguments() const { TermList* Term::termArgs() { - CALL("Term::termArgs"); ASS(!isSort()); return _args + (_arity - numTypeArguments()); @@ -337,8 +309,6 @@ const TermList* Term::typeArgs() const unsigned Term::numTermArguments() const { - CALL("Term::numTermArguments"); - if(isSuper() || isSort()) return 0; @@ -348,8 +318,6 @@ unsigned Term::numTermArguments() const bool TermList::containsSubterm(TermList trm) { - CALL("Term::containsSubterm"); - if (!isTerm()) { return trm==*this; } @@ -358,7 +326,6 @@ bool TermList::containsSubterm(TermList trm) bool Term::containsSubterm(TermList trm) { - CALL("Term::containsSubterm"); ASS(!trm.isTerm() || trm.term()->shared()); ASS(shared()); @@ -394,8 +361,6 @@ bool Term::containsSubterm(TermList trm) } size_t Term::countSubtermOccurrences(TermList subterm) { - CALL("Term::countSubtermOccurrences"); - size_t res = 0; unsigned stWeight = subterm.isTerm() ? subterm.term()->weight() : 1; @@ -417,7 +382,6 @@ size_t Term::countSubtermOccurrences(TermList subterm) { bool TermList::containsAllVariablesOf(TermList t) { - CALL("TermList::containsAllVariablesOf"); Set vars; TermIterator oldVars=Term::getVariableIterator(*this); while (oldVars.hasNext()) { @@ -434,7 +398,6 @@ bool TermList::containsAllVariablesOf(TermList t) bool Term::containsAllVariablesOf(Term* t) { - CALL("Term::containsAllVariablesOf"); static DHSet vars; vars.reset(); @@ -458,8 +421,6 @@ bool Term::containsAllVariablesOf(Term* t) bool Term::isShallow() const { - CALL("Term::isShallow"); - const TermList* t = args(); while (!t->isEmpty()) { if (t->isTerm() && t->term()->arity()>0) { @@ -472,8 +433,6 @@ bool Term::isShallow() const TermIterator Term::getVariableIterator(TermList tl) { - CALL("Term::getVariableIterator"); - if (tl.isVar()) { return pvi( getSingletonIterator(tl) ); } @@ -488,8 +447,6 @@ TermIterator Term::getVariableIterator(TermList tl) */ vstring Term::variableToString(unsigned var) { - CALL("Term::variableToString"); - return (vstring)"X" + Int::toString(var); } // variableToString @@ -499,7 +456,6 @@ vstring Term::variableToString(unsigned var) */ vstring Term::variableToString(TermList var) { - CALL("Term::variableToString"); ASS(var.isVar()); if (var.isOrdinaryVar()) { @@ -518,8 +474,6 @@ vstring Term::variableToString(TermList var) */ vstring Term::headToString() const { - CALL("Term::headToString"); - if (isSpecial()) { const Term::SpecialTermData* sd = getSpecialData(); @@ -655,8 +609,6 @@ vstring Term::headToString() const */ vstring TermList::asArgsToString() const { - CALL("TermList::asArgsToString"); - vstring res; Stack stack(64); @@ -705,8 +657,6 @@ vstring TermList::asArgsToString() const */ vstring TermList::toString(bool topLevel) const { - CALL("TermList::toString"); - if (isEmpty()) { return ""; } @@ -723,8 +673,6 @@ vstring TermList::toString(bool topLevel) const */ vstring Term::toString(bool topLevel) const { - CALL("Term::toString"); - bool printArgs = true; if(isSuper()){ @@ -760,8 +708,6 @@ vstring Term::toString(bool topLevel) const */ vstring Literal::toString() const { - CALL("Literal::toString"); - if (isEquality()) { const TermList* lhs = args(); vstring s = lhs->toString(); @@ -806,8 +752,6 @@ vstring Literal::toString() const */ const vstring& Term::functionName() const { - CALL("Term::functionName"); - #if VDEBUG static vstring nonexisting(""); if (_functor>=static_cast(env.signature->functions())) { @@ -823,8 +767,6 @@ const vstring& Term::functionName() const */ const vstring& AtomicSort::typeConName() const { - CALL("AtomcicSort::typeConName"); - #if VDEBUG static vstring nonexisting(""); if (_functor>=static_cast(env.signature->typeCons())) { @@ -841,8 +783,6 @@ const vstring& AtomicSort::typeConName() const */ const vstring& Literal::predicateName() const { - CALL("Literal::predicateName"); - #if VDEBUG static vstring nonexisting(""); if (_functor>=static_cast(env.signature->predicates())) { @@ -860,8 +800,6 @@ const vstring& Literal::predicateName() const */ Term* Term::apply(Substitution& subst) { - CALL("Term::apply"); - return SubstHelper::apply(this, subst); } // Term::apply @@ -872,8 +810,6 @@ Term* Term::apply(Substitution& subst) */ Literal* Literal::apply(Substitution& subst) { - CALL("Literal::apply"); - return SubstHelper::apply(this, subst); } // Literal::apply @@ -897,7 +833,6 @@ Literal* Literal::complementaryLiteral(Literal* l) */ Term* Term::create(Term* t,TermList* args) { - CALL("Term::create/2"); ASS_EQ(t->getPreDataSize(), 0); int arity = t->arity(); @@ -922,7 +857,6 @@ Term* Term::create(Term* t,TermList* args) */ Term* Term::create(unsigned function, unsigned arity, const TermList* args) { - CALL("Term::create/3"); ASS_EQ(env.signature->functionArity(function), arity); Term* s = new(arity) Term; @@ -953,8 +887,6 @@ Term* Term::create(unsigned function, unsigned arity, const TermList* args) */ Term* Term::createConstant(const vstring& name) { - CALL("Term::createConstant"); - unsigned symbolNumber = env.signature->addFunction(name,0); return createConstant(symbolNumber); } @@ -966,7 +898,6 @@ Term* Term::createConstant(const vstring& name) */ Term* Term::createNonShared(Term* t,TermList* args) { - CALL("Term::createNonShared/2"); int arity = t->arity(); Term* s = new(arity) Term(*t); TermList* ss = s->args(); @@ -984,7 +915,6 @@ Term* Term::createNonShared(Term* t,TermList* args) */ Term* Term::createNonShared(unsigned function, unsigned arity, TermList* args) { - CALL("Term::createNonShared/3"); ASS_EQ(env.signature->functionArity(function), arity); Term* s = new(arity) Term; @@ -1008,7 +938,6 @@ Term* Term::createNonShared(unsigned function, unsigned arity, TermList* args) */ Term* Term::createITE(Formula * condition, TermList thenBranch, TermList elseBranch, TermList branchSort) { - CALL("Term::createITE"); Term* s = new(2,sizeof(SpecialTermData)) Term; s->makeSymbol(toNormalFunctor(SpecialFunctor::ITE), 2); TermList* ss = s->args(); @@ -1027,8 +956,6 @@ Term* Term::createITE(Formula * condition, TermList thenBranch, TermList elseBra */ Term* Term::createLet(unsigned functor, VList* variables, TermList binding, TermList body, TermList bodySort) { - CALL("Term::createLet"); - #if VDEBUG Set distinctVars; VList::Iterator vit(variables); @@ -1061,8 +988,6 @@ Term* Term::createLet(unsigned functor, VList* variables, TermList binding, Term */ Term* Term::createTupleLet(unsigned tupleFunctor, VList* symbols, TermList binding, TermList body, TermList bodySort) { - CALL("Term::createTupleLet"); - #if VDEBUG Signature::Symbol* tupleSymbol = env.signature->getFunction(tupleFunctor); ASS_EQ(tupleSymbol->arity(), VList::length(symbols)); @@ -1101,8 +1026,6 @@ Term* Term::createTupleLet(unsigned tupleFunctor, VList* symbols, TermList bindi */ Term* Term::createFormula(Formula* formula) { - CALL("Term::createFormula"); - Term* s = new(0,sizeof(SpecialTermData)) Term; s->makeSymbol(toNormalFunctor(SpecialFunctor::FORMULA), 0); s->getSpecialData()->_formulaData.formula = formula; @@ -1115,8 +1038,6 @@ Term* Term::createFormula(Formula* formula) * expression and returns the resulting term */ Term* Term::createLambda(TermList lambdaExp, VList* vars, SList* sorts, TermList expSort){ - CALL("Term::createLambda"); - Term* s = new(0, sizeof(SpecialTermData)) Term; s->makeSymbol(toNormalFunctor(SpecialFunctor::LAMBDA), 0); //should store body of lambda in args @@ -1139,14 +1060,12 @@ Term* Term::createLambda(TermList lambdaExp, VList* vars, SList* sorts, TermList } Term* Term::createTuple(unsigned arity, TermList* sorts, TermList* elements) { - CALL("Term::createTuple"); unsigned tupleFunctor = Theory::tuples()->getFunctor(arity, sorts); Term* tupleTerm = Term::create(tupleFunctor, arity, elements); return createTuple(tupleTerm); } Term* Term::createTuple(Term* tupleTerm) { - CALL("Term::createTuple"); Term* s = new(0, sizeof(SpecialTermData)) Term; s->makeSymbol(toNormalFunctor(SpecialFunctor::TUPLE), 0); s->getSpecialData()->_tupleData.term = tupleTerm; @@ -1154,7 +1073,6 @@ Term* Term::createTuple(Term* tupleTerm) { } Term *Term::createMatch(TermList sort, TermList matchedSort, unsigned int arity, TermList *elements) { - CALL("Term::createMatch"); Term *s = new (arity, sizeof(SpecialTermData)) Term; s->makeSymbol(toNormalFunctor(SpecialFunctor::MATCH), arity); TermList *ss = s->args(); @@ -1176,7 +1094,6 @@ Term *Term::createMatch(TermList sort, TermList matchedSort, unsigned int arity, */ Term* Term::createNonShared(Term* t) { - CALL("Term::createNonShared/1"); int arity = t->arity(); Term* s = new(arity) Term(*t); TermList* ss = s->args(); @@ -1191,7 +1108,6 @@ Term* Term::createNonShared(Term* t) */ Term* Term::cloneNonShared(Term* t) { - CALL("Term::cloneNonShared"); int arity = t->arity(); TermList* args = t->args(); Term* s = new(arity) Term(*t); @@ -1204,15 +1120,11 @@ Term* Term::cloneNonShared(Term* t) Term* Term::create1(unsigned fn, TermList arg) { - CALL("Term::create1"); - return Term::create(fn, 1, &arg); } Term* Term::create2(unsigned fn, TermList arg1, TermList arg2) { - CALL("Term::create2"); - TermList args[] = {arg1, arg2}; return Term::create(fn, 2, args); } @@ -1220,8 +1132,6 @@ Term* Term::create2(unsigned fn, TermList arg1, TermList arg2) Term* Term::create(unsigned fn, std::initializer_list args) { - CALL("Term::create/initializer_list"); - return Term::create(fn, args.size(), args.begin()); } @@ -1229,13 +1139,11 @@ Term* Term::create(unsigned fn, std::initializer_list args) * Create singleton FOOL constants */ Term* Term::foolTrue(){ - CALL("Term::foolTrue"); static Term* _foolTrue = createConstant(env.signature->getFoolConstantSymbol(true)); return _foolTrue; } Term* Term::foolFalse(){ - CALL("Term::foolFalse"); static Term* _foolFalse = createConstant(env.signature->getFoolConstantSymbol(false)); return _foolFalse; } @@ -1245,56 +1153,46 @@ Term* Term::foolFalse(){ * and also is not linked to a symbol in the signature. */ TermList AtomicSort::superSort(){ - CALL("AtomicSort::superSort"); static AtomicSort* _super = createNonSharedConstant(0); return TermList(_super); } TermList AtomicSort::defaultSort(){ - CALL("AtomicSort::defaultSort"); static AtomicSort* _default = createConstant(env.signature->getDefaultSort()); return TermList(_default); } TermList AtomicSort::boolSort(){ - CALL("AtomicSort::boolSort"); static AtomicSort* _bool = createConstant(env.signature->getBoolSort()); return TermList(_bool); } TermList AtomicSort::intSort(){ - CALL("AtomicSort::intSort()"); static AtomicSort* _int = createConstant(env.signature->getIntSort()); return TermList(_int); } TermList AtomicSort::realSort(){ - CALL("AtomicSort::realSort()"); static AtomicSort* _real = createConstant(env.signature->getRealSort()); return TermList(_real); } TermList AtomicSort::rationalSort(){ - CALL("AtomicSort::rationalSort()"); static AtomicSort* _rat = createConstant(env.signature->getRatSort()); return TermList(_rat); } TermList AtomicSort::arrowSort(TermList s1, TermList s2){ - CALL("AtomicSort::arrowSort/1"); unsigned arrow = env.signature->getArrowConstructor(); return TermList(create2(arrow, s1, s2)); } TermList AtomicSort::arrowSort(TermList s1, TermList s2, TermList s3){ - CALL("AtomicSort::arrowSort/2"); return arrowSort(s1, arrowSort(s2, s3)); } TermList AtomicSort::arrowSort(TermStack& domSorts, TermList range) { - CALL("AtomicSort::arrowSort/3"); - TermList res = range; for(unsigned i = 0; i < domSorts.size(); i++){ @@ -1305,8 +1203,6 @@ TermList AtomicSort::arrowSort(TermStack& domSorts, TermList range) AtomicSort* AtomicSort::createConstant(const vstring& name) { - CALL("AtomicSort::createConstant"); - bool added; unsigned newSort = env.signature->addTypeCon(name,0,added); if(added){ @@ -1318,7 +1214,6 @@ AtomicSort* AtomicSort::createConstant(const vstring& name) TermList AtomicSort::arraySort(TermList indexSort, TermList innerSort) { - CALL("AtomicSort::arraySort"); unsigned array = env.signature->getArrayConstructor(); TermList sort = TermList(create2(array, indexSort, innerSort)); return sort; @@ -1326,7 +1221,6 @@ TermList AtomicSort::arraySort(TermList indexSort, TermList innerSort) TermList AtomicSort::tupleSort(unsigned arity, TermList* sorts) { - CALL("AtomicSort::tupleSort"); unsigned tuple = env.signature->getTupleConstructor(arity); TermList sort = TermList(create(tuple, arity, sorts)); return sort; @@ -1349,8 +1243,6 @@ TermList AtomicSort::tupleSort(unsigned arity, TermList* sorts) */ VList* Term::freeVariables() const { - CALL("Term::freeVariables"); - FormulaVarIterator fvi(this); VList* result = VList::empty(); VList::FIFO stack(result); @@ -1362,7 +1254,6 @@ VList* Term::freeVariables() const bool Term::isFreeVariable(unsigned var) const { - CALL("Term::isFreeVariable"); FormulaVarIterator fvi(this); while (fvi.hasNext()) { if (var == fvi.next()) { @@ -1454,7 +1345,6 @@ bool Term::isBoolean() const { } // isBoolean bool Term::isSuper() const { - CALL("Term::isSuper") return this == AtomicSort::superSort().term(); } @@ -1463,8 +1353,6 @@ bool Term::isSuper() const { */ AtomicSort* AtomicSort::create(unsigned typeCon, unsigned arity, const TermList* args) { - CALL("AtomicSort::create"); - ASS_EQ(env.signature->typeConArity(typeCon), arity); AtomicSort* s = new(arity) AtomicSort(typeCon,arity); @@ -1495,8 +1383,6 @@ AtomicSort* AtomicSort::create(unsigned typeCon, unsigned arity, const TermList* */ AtomicSort* AtomicSort::create(AtomicSort* sort,TermList* args) { - CALL("AtomicSort::create/2"); - int arity = sort->arity(); AtomicSort* s = new(arity) AtomicSort(*sort); bool share = true; @@ -1517,8 +1403,6 @@ AtomicSort* AtomicSort::create(AtomicSort* sort,TermList* args) AtomicSort* AtomicSort::create2(unsigned tc, TermList arg1, TermList arg2) { - CALL("AtomicSort::create2"); - TermList args[] = {arg1, arg2}; return AtomicSort::create(tc, 2, args); } @@ -1529,7 +1413,6 @@ AtomicSort* AtomicSort::create2(unsigned tc, TermList arg1, TermList arg2) */ AtomicSort* AtomicSort::createNonShared(unsigned typeCon, unsigned arity, TermList* args) { - CALL("AtomicSort::createNonShared"); ASS_EQ(env.signature->typeConArity(typeCon), arity); AtomicSort* s = new(arity) AtomicSort(typeCon, arity); @@ -1550,7 +1433,6 @@ AtomicSort* AtomicSort::createNonShared(unsigned typeCon, unsigned arity, TermLi */ bool Literal::headersMatch(Literal* l1, Literal* l2, bool complementary) { - CALL("Literal::headersMatch"); if (l1->_functor!=l2->_functor || (complementary?1:0)!=(l1->polarity()!=l2->polarity())) { return false; } @@ -1563,7 +1445,6 @@ bool Literal::headersMatch(Literal* l1, Literal* l2, bool complementary) */ Literal* Literal::create(unsigned predicate, unsigned arity, bool polarity, bool commutative, const TermList* args) { - CALL("Literal::create/4"); ASS_G(predicate, 0); //equality is to be created by createEquality ASS_EQ(env.signature->predicateArity(predicate), arity); @@ -1592,7 +1473,6 @@ Literal* Literal::create(unsigned predicate, unsigned arity, bool polarity, bool */ Literal* Literal::create(Literal* l,bool polarity) { - CALL("Literal::create(Literal*,bool)"); ASS_EQ(l->getPreDataSize(), 0); if (l->isEquality()) { @@ -1626,7 +1506,6 @@ Literal* Literal::create(Literal* l,bool polarity) */ Literal* Literal::create(Literal* l,TermList* args) { - CALL("Literal::create(Literal*,TermList*)"); ASS_EQ(l->getPreDataSize(), 0); if (l->isEquality()) { @@ -1662,8 +1541,6 @@ Literal* Literal::create(Literal* l,TermList* args) */ Literal* Literal::createEquality (bool polarity, TermList arg1, TermList arg2, TermList sort) { - CALL("Literal::createEquality/4"); - TermList srt1, srt2; #if VDEBUG static RobSubstitution checkSortSubst; @@ -1701,7 +1578,6 @@ Literal* Literal::createEquality (bool polarity, TermList arg1, TermList arg2, T */ Literal* Literal::createVariableEquality (bool polarity, TermList arg1, TermList arg2, TermList variableSort) { - CALL("Literal::createVariableEquality"); ASS(arg1.isVar()); ASS(arg2.isVar()); @@ -1714,14 +1590,11 @@ Literal* Literal::createVariableEquality (bool polarity, TermList arg1, TermList Literal* Literal::create1(unsigned predicate, bool polarity, TermList arg) { - CALL("Literal::create1"); - return Literal::create(predicate, 1, polarity, false, &arg); } Literal* Literal::create2(unsigned predicate, bool polarity, TermList arg1, TermList arg2) { - CALL("Literal::create2"); ASS_NEQ(predicate, 0); TermList args[] = {arg1, arg2}; @@ -1730,8 +1603,6 @@ Literal* Literal::create2(unsigned predicate, bool polarity, TermList arg1, Term Literal* Literal::create(unsigned pred, bool polarity, std::initializer_list args) { - CALL("Term::create/initializer_list"); - return Literal::create(pred, args.size(), polarity, false, args.begin()); } @@ -1747,7 +1618,6 @@ Term::Term(const Term& t) throw() _weight(0), _vars(0) { - CALL("Term::Term/1"); ASS(!isSpecial()); //we do not copy special terms _args[0] = t._args[0]; @@ -1760,14 +1630,12 @@ Term::Term(const Term& t) throw() Literal::Literal(const Literal& l) throw() : Term(l) { - CALL("Literal::Literal/1"); } /** create a new AtomicSort and copy from l its content */ AtomicSort::AtomicSort(const AtomicSort& p) throw() : Term(p) { - CALL("AtomicSort::AtomicSort/1"); } /** dummy term constructor */ @@ -1781,8 +1649,6 @@ Term::Term() throw() _maxRedLen(0), _vars(0) { - CALL("Term::Term/0"); - _args[0]._info.polarity = 0; _args[0]._info.commutative = 0; _args[0]._info.shared = 0; @@ -1796,12 +1662,10 @@ Term::Term() throw() Literal::Literal() { - CALL("Literal::Literal/0"); } AtomicSort::AtomicSort() { - CALL("AtomicSort::AtomicSort/0"); } #if VDEBUG @@ -1872,7 +1736,6 @@ bool operator<(const TermList& lhs, const TermList& rhs) bool Kernel::positionIn(TermList& subterm,TermList* term,vstring& position) { - CALL("positionIn(TermList)"); //cout << "positionIn " << subterm.toString() << " in " << term->toString() << endl; if(!term->isTerm()){ @@ -1888,7 +1751,6 @@ bool Kernel::positionIn(TermList& subterm,TermList* term,vstring& position) bool Kernel::positionIn(TermList& subterm,Term* term,vstring& position) { - CALL("positionIn(Term)"); //cout << "positionIn " << subterm.toString() << " in " << term->toString() << endl; if(subterm.isTerm() && subterm.term()==term){ diff --git a/Kernel/Term.hpp b/Kernel/Term.hpp index e5f3b8441..bbd3f95a2 100644 --- a/Kernel/Term.hpp +++ b/Kernel/Term.hpp @@ -31,7 +31,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Allocator.hpp" #include "Lib/Portability.hpp" @@ -508,7 +507,6 @@ class Term * @since 28/12/2007 Manchester */ unsigned hash() const { - CALL("Term::hash"); return DefaultHash::hashBytes( reinterpret_cast(_args+1), _arity*sizeof(TermList), @@ -623,8 +621,6 @@ class Term /** Set the number of variable _occurrences_ */ void setNumVarOccs(unsigned v) { - CALL("Term::setNumVarOccs"); - if(_isTwoVarEquality) { ASS_EQ(v,2); return; @@ -634,7 +630,6 @@ class Term void setHasTermVar(bool b) { - CALL("setHasTermVar"); ASS(shared() && !isSort()); _args[0]._info.hasTermVar = b; } @@ -642,7 +637,6 @@ class Term /** Return the number of variable _occurrences_ */ unsigned numVarOccs() const { - CALL("Term::numVarOccs"); ASS(shared()); if(_isTwoVarEquality) { return _sort.isVar() ? 3 : 2 + _sort.term()->numVarOccs(); @@ -674,8 +668,6 @@ class Term /** Return an index of the argument to which @b arg points */ unsigned getArgumentIndex(TermList* arg) { - CALL("Term::getArgumentIndex"); - unsigned res=arity()-(arg-_args); ASS_L(res,arity()); return res; @@ -757,7 +749,6 @@ class Term /** Return pointer to structure containing extra data for special terms such as * if-then-else or let...in */ SpecialTermData* getSpecialData() { - CALL("Term::getSpecialData"); ASS(isSpecial()); return reinterpret_cast(this)-1; } @@ -788,7 +779,6 @@ class Term */ void setArgumentOrderValue(ArgumentOrderVals val) { - CALL("Term::setArgumentOrderValue"); ASS_GE(val,AO_UNKNOWN); ASS_LE(val,AO_INCOMPARABLE); @@ -841,7 +831,6 @@ class Term bool hasNext() const { return _next->isNonEmpty(); } TermList next() { - CALL("Term::Iterator::next"); ASS(hasNext()); TermList res = *_next; _next = _next->next(); @@ -968,7 +957,6 @@ class Literal template unsigned hash() const { - CALL("Literal::hash"); bool positive = (flip ^ isPositive()); unsigned hash = DefaultHash::hash(positive ? (2*_functor) : (2*_functor+1)); if (isTwoVarEquality()) { @@ -1013,7 +1001,6 @@ class Literal */ void markTwoVarEquality() { - CALL("Literal::markTwoVarEquality"); ASS(!shared()); ASS(isEquality()); ASS(nthArgument(0)->isVar() || !nthArgument(0)->term()->shared()); @@ -1028,7 +1015,6 @@ class Literal */ TermList twoVarEqSort() const { - CALL("Literal::twoVarEqSort"); ASS(isTwoVarEquality()); return _sort; @@ -1037,7 +1023,6 @@ class Literal /** Assign sort of the variables in an equality between two variables. */ void setTwoVarEqSort(TermList sort) { - CALL("Literal::setTwoVarEqSort"); ASS(isTwoVarEquality()); _sort = sort; diff --git a/Kernel/TermIterators.cpp b/Kernel/TermIterators.cpp index 48d8ae413..01fe6c09e 100644 --- a/Kernel/TermIterators.cpp +++ b/Kernel/TermIterators.cpp @@ -13,7 +13,6 @@ */ -#include "Debug/Tracer.hpp" #include "Term.hpp" #include "Signature.hpp" @@ -31,7 +30,6 @@ typedef ApplicativeHelper AH; */ bool VariableIterator::hasNext() { - CALL("VariableIterator::hasNext"); if(_stack.isEmpty()) { return false; } @@ -66,7 +64,6 @@ bool VariableIterator::hasNext() bool VariableWithSortIterator::hasNext() { - CALL("VariableWithSortIterator::hasNext"); if(_stack.isEmpty()) { return false; } @@ -111,8 +108,6 @@ bool VariableWithSortIterator::hasNext() */ bool SubtermIterator::hasNext() { - CALL("SubtermIterator::hasNext"); - if(_stack->isEmpty()) { return false; } @@ -136,7 +131,6 @@ bool SubtermIterator::hasNext() */ void SubtermIterator::right() { - CALL("SubtermIterator::right"); ASS(_stack->isNonEmpty()); ASS(_used); @@ -157,8 +151,6 @@ void SubtermIterator::right() bool TopLevelVarLikeTermIterator::hasNext() { - CALL("TopLevelVarLikeTermIterator::hasNext"); - static TermStack args; TermList head; @@ -208,8 +200,6 @@ TopLevelVarIterator::TopLevelVarIterator(TermList t) bool TopLevelVarIterator::hasNext() { - CALL("TopLevelVarIterator::hasNext"); - static TermStack args; static TermStack args2; args.reset(); @@ -245,8 +235,6 @@ bool TopLevelVarIterator::hasNext() Term* FirstOrderSubtermIt::next() { - CALL("FirstOrderSubtermIt::next"); - static TermStack args; _added = 0; TermList head; @@ -266,8 +254,6 @@ Term* FirstOrderSubtermIt::next() void FirstOrderSubtermIt::right() { - CALL("FirstOrderSubtermIt::right"); - while (_added > 0) { _added--; _stack.pop(); @@ -277,8 +263,6 @@ void FirstOrderSubtermIt::right() bool NarrowableSubtermIt::hasNext() { - CALL("NarrowableSubtermIt::hasNext"); - if(!_used){ return true; } static TermStack args; @@ -310,8 +294,6 @@ bool NarrowableSubtermIt::hasNext() bool BooleanSubtermIt::hasNext() { - CALL("BooleanSubtermIt::hasNext"); - if(!_used){ return true; } static TermStack args; @@ -336,8 +318,6 @@ bool BooleanSubtermIt::hasNext() bool RewritableVarsIt::hasNext() { - CALL("RewritableVarsIt::hasNext"); - if(_next.isSome()){ return true; } static TermStack args; @@ -366,8 +346,6 @@ bool RewritableVarsIt::hasNext() //TODO relook at stability and instability bool UnstableVarIt::hasNext() { - CALL("UnstableVarIt::hasNext"); - if(!_next.isEmpty()){ return true; } static TermStack args; @@ -405,8 +383,6 @@ bool UnstableVarIt::hasNext() */ bool PolishSubtermIterator::hasNext() { - CALL("PolishSubtermIterator::hasNext"); - if(_stack.isEmpty()) { return false; } @@ -429,8 +405,6 @@ bool PolishSubtermIterator::hasNext() */ TermList NonVariableIterator::next() { - CALL("NonVariableIterator::next"); - Term* t = _stack.pop(); _added = 0; Term::Iterator ts(t); @@ -450,8 +424,6 @@ TermList NonVariableIterator::next() */ void NonVariableIterator::right() { - CALL("NonVariableIterator::right"); - while (_added > 0) { _added--; _stack.pop(); @@ -465,8 +437,6 @@ void NonVariableIterator::right() */ Term* NonVariableNonTypeIterator::next() { - CALL("NonVariableNonTypeIterator::next"); - Term* t = _stack.pop(); TermList* ts; _added = 0; @@ -502,8 +472,6 @@ Term* NonVariableNonTypeIterator::next() */ void NonVariableNonTypeIterator::right() { - CALL("NonVariableNonTypeIterator::right"); - while (_added > 0) { _added--; _stack.pop(); @@ -515,8 +483,6 @@ void NonVariableNonTypeIterator::right() */ // bool NonVariableIterator::hasNext() // { -// CALL("NonVariableIterator::hasNext"); - // if(_stack.isEmpty()) { // return false; // } @@ -539,7 +505,6 @@ void NonVariableNonTypeIterator::right() // */ // void NonVariableIterator::right() // { -// CALL("NonVariableIterator::right"); // ASS(_stack.isNonEmpty()); // ASS(_used); @@ -571,7 +536,6 @@ void NonVariableNonTypeIterator::right() */ bool DisagreementSetIterator::hasNext() { - CALL("DisagreementSetIterator::hasNext"); ASS(_stack.size()%2==0); if(!_arg1.isEmpty()) { @@ -619,8 +583,6 @@ bool DisagreementSetIterator::hasNext() TermFunIterator::TermFunIterator (const Term* t) : _stack(64) { - CALL("TermFunIterator::TermFunIterator"); - _hasNext = true; _next = t->functor(); _stack.push(t->args()); @@ -633,8 +595,6 @@ TermFunIterator::TermFunIterator (const Term* t) */ bool TermFunIterator::hasNext () { - CALL("TermFunIterator::hasNext"); - if (_hasNext) { return true; } @@ -664,8 +624,6 @@ bool TermFunIterator::hasNext () */ unsigned TermFunIterator::next () { - CALL("TermFunIterator::hasNext"); - ASS(_hasNext); _hasNext = false; @@ -681,7 +639,6 @@ unsigned TermFunIterator::next () TermVarIterator::TermVarIterator (const Term* t) : _stack(64) { - CALL("TermVarIterator::TermVarIterator"); //TODO update for two var lits? _stack.push(t->args()); } // TermVarIterator::TermVarIterator @@ -694,7 +651,6 @@ TermVarIterator::TermVarIterator (const Term* t) TermVarIterator::TermVarIterator (const TermList* ts) : _stack(64) { - CALL("TermVarIterator::TermVarIterator"); _stack.push(ts); } // TermVarIterator::TermVarIterator @@ -706,8 +662,6 @@ TermVarIterator::TermVarIterator (const TermList* ts) */ bool TermVarIterator::hasNext () { - CALL("TermVarIterator::hasNext"); - while (_stack.isNonEmpty()) { const TermList* ts = _stack.pop(); if (ts->isEmpty()) { @@ -731,7 +685,6 @@ bool TermVarIterator::hasNext () */ unsigned TermVarIterator::next () { - CALL("TermVarIterator::next"); return _next; } // TermVarIterator::next diff --git a/Kernel/TermIterators.hpp b/Kernel/TermIterators.hpp index 0364f9cea..1e7e86580 100644 --- a/Kernel/TermIterators.hpp +++ b/Kernel/TermIterators.hpp @@ -140,7 +140,6 @@ struct OrdVarNumberExtractorFn { unsigned operator()(TermList t) { - CALL("OrdVarNumberExtractorFn::operator()"); ASS(t.isOrdinaryVar()); return t.var(); @@ -360,8 +359,6 @@ class RewritableVarsIt DECL_ELEMENT_TYPE(TypedTermList); RewritableVarsIt(DHSet* unstableVars, Term* t, bool includeSelf = false) : _next(), _stack(8) { - CALL("RewritableVarsIt"); - _unstableVars = unstableVars; if(t->isLiteral()){ TermList t0 = *t->nthArgument(0); @@ -399,7 +396,6 @@ class UnstableVarIt public: UnstableVarIt(Term* t) : _stable(8), _stack(8) { - CALL("UnstableVarIt"); _next.makeEmpty(); if(t->isLiteral()){ _stack.push(*t->nthArgument(0)); @@ -434,7 +430,6 @@ class FirstOrderSubtermIt FirstOrderSubtermIt(Term* term, bool includeSelf=false) : _stack(8), _added(0) { - CALL("FirstOrderSubtermIt::FirstOrderSubtermIt"); if(term->isLiteral()){ TermList t0 = *term->nthArgument(0); TermList t1 = *term->nthArgument(1); @@ -465,7 +460,6 @@ class NarrowableSubtermIt NarrowableSubtermIt(Term* term, bool includeSelf=false) : _used(true), _stack(8) { - CALL("NarrowableSubtermIt::NarrowableSubtermIt"); if(term->isLiteral()){ TermList t0 = *term->nthArgument(0); TermList t1 = *term->nthArgument(1); @@ -500,7 +494,6 @@ class BooleanSubtermIt BooleanSubtermIt(Term* term, bool includeSelf=false) : _used(true), _stack(8) { - CALL("BooleanSubtermIt::BooleanSubtermIt"); if(term->isLiteral()){ TermList t0 = *term->nthArgument(0); TermList t1 = *term->nthArgument(1); @@ -541,7 +534,6 @@ class ReversedCommutativeSubtermIterator public: ReversedCommutativeSubtermIterator(const Term* trm) { - CALL("Term::ReversedCommutativeSubtermIterator::ReversedCommutativeSubtermIterator"); ASS(trm->commutative()); ASS_EQ(trm->arity(),2); @@ -620,7 +612,6 @@ class NonVariableIterator : _stack(8), _added(0) { - CALL("NonVariableIterator::NonVariableIterator"); _stack.push(term); if (!includeSelf) { NonVariableIterator::next(); @@ -663,7 +654,6 @@ class NonVariableNonTypeIterator : _stack(8), _added(0) { - CALL("NonVariableNonTypeIterator::NonVariableNonTypeIterator"); _stack.push(term); if (!includeSelf) { NonVariableNonTypeIterator::next(); @@ -706,7 +696,6 @@ class DisagreementSetIterator DisagreementSetIterator(TermList t1, TermList t2, bool disjunctVariables=true) : _stack(8) { - CALL("Term::DisagreementSetIterator::DisagreementSetIterator(TermList...)"); reset(t1, t2, disjunctVariables); } /** @@ -716,13 +705,11 @@ class DisagreementSetIterator DisagreementSetIterator(Term* t1, Term* t2, bool disjunctVariables=true) : _stack(8), _disjunctVariables(disjunctVariables) { - CALL("Term::DisagreementSetIterator::DisagreementSetIterator(Term*...)"); reset(t1,t2,disjunctVariables); } void reset(TermList t1, TermList t2, bool disjunctVariables=true) { - CALL("Term::DisagreementSetIterator::reset(TermList...)"); ASS(!t1.isEmpty()); ASS(!t2.isEmpty()); @@ -742,7 +729,6 @@ class DisagreementSetIterator void reset(Term* t1, Term* t2, bool disjunctVariables=true) { - CALL("Term::DisagreementSetIterator::reset(Term*...)"); ASS_EQ(t1->functor(), t2->functor()); _stack.reset(); diff --git a/Kernel/TermTransformer.cpp b/Kernel/TermTransformer.cpp index e22c51959..633587ff8 100644 --- a/Kernel/TermTransformer.cpp +++ b/Kernel/TermTransformer.cpp @@ -27,8 +27,6 @@ namespace Kernel */ Term* TermTransformer::transform(Term* term) { - CALL("TermTransformer::transform(Term* term)"); - if (term->isSpecial()) { return transformSpecial(term); } @@ -136,7 +134,6 @@ Term* TermTransformer::transform(Term* term) Literal* TermTransformer::transform(Literal* lit) { - CALL("TermTransformer::transform(Literal* lit)"); Term* t = transform(static_cast(lit)); ASS(t->isLiteral()); return static_cast(t); @@ -144,7 +141,6 @@ Literal* TermTransformer::transform(Literal* lit) Term* TermTransformer::transformSpecial(Term* term) { - CALL("TermTransformer::transformSpecial(Term* term)"); ASS(term->isSpecial()); Term::SpecialTermData* sd = term->getSpecialData(); @@ -228,8 +224,6 @@ Term* TermTransformer::transformSpecial(Term* term) TermList TermTransformer::transform(TermList ts) { - CALL("TermTransformer::transform(TermList ts)"); - if (ts.isVar()) { return transformSubterm(ts); } else { @@ -244,14 +238,12 @@ TermList TermTransformer::transform(TermList ts) Formula* TermTransformer::transform(Formula* f) { - CALL("TermTransformer::transform(Formula* f)"); TermTransformingFormulaTransformer ttft(*this); return ttft.transform(f); } Term* BottomUpTermTransformer::transform(Term* term) { - CALL("BottomUpTermTransformer::transform(Term* term)"); ASS(term->shared()); static Stack toDo(8); @@ -340,7 +332,6 @@ Term* BottomUpTermTransformer::transform(Term* term) Literal* BottomUpTermTransformer::transform(Literal* lit) { - CALL("TermTransformer::transform(Literal* lit)"); Term* t = transform(static_cast(lit)); ASS(t->isLiteral()); return static_cast(t); @@ -348,7 +339,6 @@ Literal* BottomUpTermTransformer::transform(Literal* lit) Formula* BottomUpTermTransformer::transform(Formula* f) { - CALL("BottomUpTermTransformer::transform(Formula* f)"); static BottomUpTermTransformerFormulaTransformer ttft(*this); return ttft.transform(f); } diff --git a/Kernel/Theory.cpp b/Kernel/Theory.cpp index 54f48f8d7..812063dce 100644 --- a/Kernel/Theory.cpp +++ b/Kernel/Theory.cpp @@ -15,7 +15,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" #include "Lib/Int.hpp" @@ -42,8 +41,6 @@ using namespace Lib; IntegerConstantType::IntegerConstantType(const vstring& str) { - CALL("IntegerConstantType::IntegerConstantType(vstring)"); - if (!Int::stringToInt(str, _val)) { throw MachineArithmeticException(); } @@ -51,8 +48,6 @@ IntegerConstantType::IntegerConstantType(const vstring& str) IntegerConstantType IntegerConstantType::operator+(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator+"); - InnerType res; if (!Int::safePlus(_val, num._val, res)) { throw MachineArithmeticException(); @@ -62,8 +57,6 @@ IntegerConstantType IntegerConstantType::operator+(const IntegerConstantType& nu IntegerConstantType IntegerConstantType::operator-(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator-/1"); - InnerType res; if (!Int::safeMinus(_val, num._val, res)) { throw MachineArithmeticException(); @@ -73,8 +66,6 @@ IntegerConstantType IntegerConstantType::operator-(const IntegerConstantType& nu IntegerConstantType IntegerConstantType::operator-() const { - CALL("IntegerConstantType::operator-/0"); - InnerType res; if (!Int::safeUnaryMinus(_val, res)) { throw MachineArithmeticException(); @@ -84,8 +75,6 @@ IntegerConstantType IntegerConstantType::operator-() const IntegerConstantType IntegerConstantType::operator*(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator*"); - InnerType res; if (!Int::safeMultiply(_val, num._val, res)) { throw MachineArithmeticException(); @@ -102,15 +91,12 @@ inline typename IntegerConstantType::InnerType divideOrThrow(typename IntegerCon int IntegerConstantType::intDivide(const IntegerConstantType& num) const { - CALL("IntegerConstantType::intDivide"); ASS_REP(num.divides(*this), num.toString() + " does not divide " + this->toString() ); return divideOrThrow(_val, num._val); } IntegerConstantType IntegerConstantType::remainderE(const IntegerConstantType& num) const { - CALL("IntegerConstantType::remainderE"); - if (num._val == 0) { throw MachineArithmeticException(); } @@ -156,8 +142,6 @@ IntegerConstantType IntegerConstantType::abs() const */ IntegerConstantType IntegerConstantType::quotientE(const IntegerConstantType& num) const { - CALL("IntegerConstantType::quotientE"); - if (num._val == 0) { throw DivByZeroException(); } @@ -209,7 +193,6 @@ IntegerConstantType IntegerConstantType::quotientT(const IntegerConstantType& nu bool IntegerConstantType::divides(const IntegerConstantType& num) const { - CALL("IntegerConstantType:divides"); if (_val == 0) { return false; } if (num._val == _val) { return true; } if (num._val == numeric_limits::min() && _val == -1) { @@ -222,8 +205,6 @@ bool IntegerConstantType::divides(const IntegerConstantType& num) const //TODO remove this operator. We already have 3 other ways of computing the remainder, required by the semantics of TPTP and SMTCOMP. IntegerConstantType IntegerConstantType::operator%(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator%"); - //TODO: check if modulo corresponds to the TPTP semantic if (num._val==0) { throw DivByZeroException(); @@ -233,15 +214,11 @@ IntegerConstantType IntegerConstantType::operator%(const IntegerConstantType& nu bool IntegerConstantType::operator==(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator=="); - return _val==num._val; } bool IntegerConstantType::operator>(const IntegerConstantType& num) const { - CALL("IntegerConstantType::operator>"); - return _val>num._val; } @@ -250,8 +227,6 @@ IntegerConstantType IntegerConstantType::floor(IntegerConstantType x) IntegerConstantType IntegerConstantType::floor(RationalConstantType rat) { - CALL("IntegerConstantType::floor"); - IntegerConstantType num = rat.numerator(); IntegerConstantType den = rat.denominator(); if (den == IntegerConstantType(1)) { @@ -275,8 +250,6 @@ IntegerConstantType IntegerConstantType::ceiling(IntegerConstantType x) */ IntegerConstantType IntegerConstantType::ceiling(RationalConstantType rat) { - CALL("IntegerConstantType::ceiling"); - IntegerConstantType num = rat.numerator(); IntegerConstantType den = rat.denominator(); if (den == IntegerConstantType(1)) { @@ -293,7 +266,6 @@ IntegerConstantType IntegerConstantType::ceiling(RationalConstantType rat) Comparison IntegerConstantType::comparePrecedence(IntegerConstantType n1, IntegerConstantType n2) { - CALL("IntegerConstantType::comparePrecedence"); try { if (n1 == numeric_limits::min()) { if (n2 == numeric_limits::min()) { @@ -325,8 +297,6 @@ Comparison IntegerConstantType::comparePrecedence(IntegerConstantType n1, Intege vstring IntegerConstantType::toString() const { - CALL("IntegerConstantType::toString"); - return Int::toString(_val); } @@ -336,22 +306,16 @@ vstring IntegerConstantType::toString() const RationalConstantType::RationalConstantType(InnerType num, InnerType den) { - CALL("RationalConstantType::RationalConstantType"); - init(num, den); } RationalConstantType::RationalConstantType(const vstring& num, const vstring& den) { - CALL("RationalConstantType::RationalConstantType"); - init(InnerType(num), InnerType(den)); } void RationalConstantType::init(InnerType num, InnerType den) { - CALL("RationalConstantType::init"); - _num = num; _den = den; cannonize(); @@ -362,8 +326,6 @@ void RationalConstantType::init(InnerType num, InnerType den) RationalConstantType RationalConstantType::operator+(const RationalConstantType& o) const { - CALL("RationalConstantType::operator+"); - if (_den==o._den) { return RationalConstantType(_num + o._num, _den); } @@ -372,28 +334,21 @@ RationalConstantType RationalConstantType::operator+(const RationalConstantType& RationalConstantType RationalConstantType::operator-(const RationalConstantType& o) const { - CALL("RationalConstantType::operator-/1"); - return (*this) + (-o); } RationalConstantType RationalConstantType::operator-() const { - CALL("RationalConstantType::operator-/0"); - return RationalConstantType(-_num, _den); } RationalConstantType RationalConstantType::operator*(const RationalConstantType& o) const { - CALL("RationalConstantType::operator*"); - return RationalConstantType(_num*o._num, _den*o._den); } RationalConstantType RationalConstantType::operator/(const RationalConstantType& o) const { - CALL("RationalConstantType::operator/"); auto lhs = *this; auto rhs = o; return RationalConstantType( @@ -403,21 +358,16 @@ RationalConstantType RationalConstantType::operator/(const RationalConstantType& bool RationalConstantType::isInt() const { - CALL("RationalConstantType::isInt"); - return _den==1; } bool RationalConstantType::operator==(const RationalConstantType& o) const { - CALL("IntegerConstantType::operator=="); - return _num==o._num && _den==o._den; } bool RationalConstantType::operator>(const RationalConstantType& o) const { - CALL("IntegerConstantType::operator>"); /* prevents overflows */ auto toLong = [](IntegerConstantType t) -> long int { return t.toInner(); }; @@ -428,8 +378,6 @@ bool RationalConstantType::operator>(const RationalConstantType& o) const vstring RationalConstantType::toString() const { - CALL("RationalConstantType::toString"); - vstring numStr = _num.toString(); vstring denStr = _den.toString(); @@ -443,8 +391,6 @@ vstring RationalConstantType::toString() const */ void RationalConstantType::cannonize() { - CALL("RationalConstantType::cannonize"); - unsigned gcd = Int::gcd(_num.toInner(), _den.toInner()); if (gcd == (unsigned)(-(long long)(numeric_limits::min()))) { // we are talking about 2147483648, but I can't take minus of it's int representation! ASS_EQ(_num, numeric_limits::min()); @@ -472,7 +418,6 @@ void RationalConstantType::cannonize() Comparison RationalConstantType::comparePrecedence(RationalConstantType n1, RationalConstantType n2) { - CALL("RationalConstantType::comparePrecedence"); /* cannot overflow */ auto prec = IntegerConstantType::comparePrecedence(n1._den, n2._den); if (prec != EQUAL) return prec; @@ -537,15 +482,11 @@ Comparison RationalConstantType::comparePrecedence(RationalConstantType n1, Rati Comparison RealConstantType::comparePrecedence(RealConstantType n1, RealConstantType n2) { - CALL("RealConstantType::comparePrecedence"); - return RationalConstantType::comparePrecedence(n1, n2); } bool RealConstantType::parseDouble(const vstring& num, RationalConstantType& res) { - CALL("RealConstantType::parseDouble"); - try { vstring newNum; IntegerConstantType denominator = 1; @@ -591,8 +532,6 @@ bool RealConstantType::parseDouble(const vstring& num, RationalConstantType& res RealConstantType::RealConstantType(const vstring& number) { - CALL("RealConstantType::RealConstantType"); - RationalConstantType value; if (parseDouble(number, value)) { init(value.numerator(), value.denominator()); @@ -626,8 +565,6 @@ RealConstantType::RealConstantType(const vstring& number) vstring RealConstantType::toNiceString() const { - CALL("RealConstantType::toNiceString"); - if (denominator().toInner()==1) { return numerator().toString()+".0"; } @@ -675,7 +612,6 @@ Theory::Theory() */ unsigned Theory::getArity(Interpretation i) { - CALL("Signature::InterpretedSymbol::getArity"); ASS_L(i,INVALID_INTERPRETATION); switch(i) { @@ -792,7 +728,6 @@ unsigned Theory::getArity(Interpretation i) */ bool Theory::isFunction(Interpretation i) { - CALL("Signature::InterpretedSymbol::isFunction"); ASS_L(i,INVALID_INTERPRETATION); switch(i) { @@ -904,7 +839,6 @@ bool Theory::isFunction(Interpretation i) */ bool Theory::isInequality(Interpretation i) { - CALL("Signature::InterpretedSymbol::isInequality"); ASS_L(i,INVALID_INTERPRETATION); switch(i) { @@ -935,8 +869,6 @@ bool Theory::isInequality(Interpretation i) */ bool Theory::hasSingleSort(Interpretation i) { - CALL("Theory::hasSingleSort"); - switch(i) { case EQUAL: // This not SingleSort because we don't know the sorts of its args case INT_TO_RAT: @@ -958,8 +890,6 @@ bool Theory::hasSingleSort(Interpretation i) bool Theory::isPolymorphic(Interpretation i) { - CALL("Theory::isPolymorphic"); - if (i >= numberOfFixedInterpretations()) { // indexed are all polymorphic (for now) return true; } @@ -982,8 +912,6 @@ bool Theory::isPolymorphic(Interpretation i) */ TermList Theory::getOperationSort(Interpretation i) { - CALL("Theory::getOperationSort"); - ASS(hasSingleSort(i)); ASS_L(i,INVALID_INTERPRETATION); ASS(!isPolymorphic(i)); @@ -1076,8 +1004,6 @@ TermList Theory::getOperationSort(Interpretation i) bool Theory::isConversionOperation(Interpretation i) { - CALL("Theory::isConversionOperation"); - //we do not include operations as INT_TO_INT here because they actually //don't convert anything (they're identities) switch(i) { @@ -1094,8 +1020,6 @@ bool Theory::isConversionOperation(Interpretation i) } bool Theory::isLinearOperation(Interpretation i) { - CALL("Theory::isLinearOperation"); - switch(i) { case INT_UNARY_MINUS: case INT_PLUS: @@ -1113,8 +1037,6 @@ bool Theory::isLinearOperation(Interpretation i) } bool Theory::isNonLinearOperation(Interpretation i) { - CALL("Theory::isNonLinearOperation"); - switch(i) { case INT_MULTIPLY: case INT_QUOTIENT_E: @@ -1146,7 +1068,6 @@ bool Theory::isNonLinearOperation(Interpretation i) } bool Theory::isPartiallyInterpretedFunction(Term* t) { - CALL("Theory::isPartiallyInterpretedFunction(Term* t)") auto f = t->functor(); ASS(!t->isLiteral()) if(theory->isInterpretedFunction(f)) { @@ -1191,7 +1112,6 @@ bool Theory::isPartiallyInterpretedFunction(Term* t) { } bool Theory::partiallyDefinedFunctionUndefinedForArgs(Term* t) { - CALL("Theory::partiallyDefinedFunctionUndefinedForArgs(Term* t)") ASS(isPartiallyInterpretedFunction(t)) auto f = t->functor(); ASS(!t->isLiteral()) @@ -1267,7 +1187,6 @@ bool Theory::partiallyDefinedFunctionUndefinedForArgs(Term* t) { * We want to have this function available e.g. in simplification rules. */ unsigned Theory::getArrayExtSkolemFunction(TermList sort) { - CALL("Theory::getArrayExtSkolemFunction") ASS(sort.isArraySort()); if(_arraySkolemFunctions.find(sort)){ @@ -1284,13 +1203,10 @@ unsigned Theory::getArrayExtSkolemFunction(TermList sort) { } unsigned Theory::Tuples::getFunctor(unsigned arity, TermList* sorts) { - CALL("Theory::Tuples::getFunctor(unsigned arity, unsigned* sorts)"); return getFunctor(AtomicSort::tupleSort(arity, sorts)); } unsigned Theory::Tuples::getFunctor(TermList tupleSort) { - CALL("Theory::Tuples::getFunctor(unsigned tupleSort)"); - ASS_REP(tupleSort.isTupleSort(), tupleSort.toString()); unsigned arity = tupleSort.term()->arity(); @@ -1304,14 +1220,11 @@ unsigned Theory::Tuples::getFunctor(TermList tupleSort) { } bool Theory::Tuples::isFunctor(unsigned functor) { - CALL("Theory::Tuples::isFunctor(unsigned)"); TermList tupleSort = env.signature->getFunction(functor)->fnType()->result(); return tupleSort.isTupleSort(); } unsigned Theory::Tuples::getProjectionFunctor(unsigned proj, TermList tupleSort) { - CALL("Theory::Tuples::getProjectionFunctor"); - ASS_REP(tupleSort.isTupleSort(), tupleSort.toString()); unsigned arity = tupleSort.term()->arity(); @@ -1330,8 +1243,6 @@ unsigned Theory::Tuples::getProjectionFunctor(unsigned proj, TermList tupleSort) // TODO: replace with a constant time algorithm bool Theory::Tuples::findProjection(unsigned projFunctor, bool isPredicate, unsigned &proj) { - CALL("Theory::Tuples::findProjection"); - OperatorType* projType = isPredicate ? env.signature->getPredicate(projFunctor)->predType() : env.signature->getFunction(projFunctor)->fnType(); @@ -1368,8 +1279,6 @@ bool Theory::Tuples::findProjection(unsigned projFunctor, bool isPredicate, unsi */ OperatorType* Theory::getConversionOperationType(Interpretation i) { - CALL("Theory::getConversionOperationType"); - TermList from, to; switch(i) { case INT_TO_RAT: @@ -1403,8 +1312,6 @@ OperatorType* Theory::getConversionOperationType(Interpretation i) } vstring Theory::getInterpretationName(Interpretation interp) { - CALL("Theory::getInterpretationName"); - switch (interp) { case INT_SUCCESSOR: //this one is not according the TPTP arithmetic (it doesn't have successor) @@ -1519,7 +1426,6 @@ vstring Theory::getInterpretationName(Interpretation interp) { } OperatorType* Theory::getArrayOperatorType(TermList arraySort, Interpretation i) { - CALL("Theory::getArrayOperatorType"); ASS(arraySort.isArraySort()); TermList indexSort = SortHelper::getIndexSort(arraySort); @@ -1545,7 +1451,6 @@ OperatorType* Theory::getArrayOperatorType(TermList arraySort, Interpretation i) */ OperatorType* Theory::getNonpolymorphicOperatorType(Interpretation i) { - CALL("Theory::getNonpolymorphicOperationType"); ASS(!isPolymorphic(i)); if (isConversionOperation(i)) { @@ -1568,8 +1473,6 @@ OperatorType* Theory::getNonpolymorphicOperatorType(Interpretation i) } void Theory::defineTupleTermAlgebra(unsigned arity, TermList* sorts) { - CALL("Signature::defineTupleTermAlgebra"); - TermList tupleSort = AtomicSort::tupleSort(arity, sorts); if (env.signature->isTermAlgebraSort(tupleSort)) { @@ -1607,8 +1510,6 @@ void Theory::defineTupleTermAlgebra(unsigned arity, TermList* sorts) { bool Theory::isInterpretedConstant(unsigned func) { - CALL("Theory::isInterpretedConstant"); - if (func>=Term::SPECIAL_FUNCTOR_LOWER_BOUND) { return false; } @@ -1621,8 +1522,6 @@ bool Theory::isInterpretedConstant(unsigned func) */ bool Theory::isInterpretedConstant(Term* t) { - CALL("Theory::isInterpretedConstant(Term*)"); - if (t->isSpecial()) { return false; } return t->numTermArguments()==0 && env.signature->getFunction(t->functor())->interpreted(); @@ -1633,8 +1532,6 @@ bool Theory::isInterpretedConstant(Term* t) */ bool Theory::isInterpretedConstant(TermList t) { - CALL("Theory::isInterpretedConstant(TermList)"); - return t.isTerm() && isInterpretedConstant(t.term()); } @@ -1643,8 +1540,6 @@ bool Theory::isInterpretedConstant(TermList t) */ bool Theory::isInterpretedNumber(Term* t) { - CALL("Theory::isInterpretedNumber(TermList)"); - return isInterpretedConstant(t) && env.signature->getFunction(t->functor())->interpretedNumber(); } @@ -1653,8 +1548,6 @@ bool Theory::isInterpretedNumber(Term* t) */ bool Theory::isInterpretedNumber(TermList t) { - CALL("Theory::isInterpretedNumber(TermList)"); - return isInterpretedConstant(t) && env.signature->getFunction(t.term()->functor())->interpretedNumber(); } @@ -1663,8 +1556,6 @@ bool Theory::isInterpretedNumber(TermList t) */ bool Theory::isInterpretedPredicate(unsigned pred) { - CALL("Theory::isInterpretedPredicate(unsigned)"); - return env.signature->getPredicate(pred)->interpreted(); } @@ -1673,8 +1564,6 @@ bool Theory::isInterpretedPredicate(unsigned pred) */ bool Theory::isInterpretedEquality(Literal* lit) { - CALL("Theory::isInterpretedEquality"); - if(lit->isEquality()){ TermList srt = SortHelper::getEqualityArgumentSort(lit); // TODO should this return true for datatypes, arrays, etc? @@ -1690,8 +1579,6 @@ bool Theory::isInterpretedEquality(Literal* lit) */ bool Theory::isInterpretedPredicate(Literal* lit) { - CALL("Theory::isInterpretedPredicate/1"); - return env.signature->getPredicate(lit->functor())->interpreted(); } @@ -1702,15 +1589,11 @@ bool Theory::isInterpretedPredicate(Literal* lit) */ bool Theory::isInterpretedPredicate(Literal* lit, Interpretation itp) { - CALL("Theory::isInterpretedPredicate/2"); - return isInterpretedPredicate(lit) && interpretPredicate(lit)==itp; } bool Theory::isInterpretedFunction(unsigned func) { - CALL("Theory::isInterpretedFunction(unsigned)"); - if (func>=Term::SPECIAL_FUNCTOR_LOWER_BOUND) { return false; } @@ -1720,9 +1603,6 @@ bool Theory::isInterpretedFunction(unsigned func) bool Theory::isZero(TermList term) { - CALL("Theory::isZero"); - - IntegerConstantType it; if(tryInterpretConstant(term,it) && it.isZero()){ return true; } @@ -1741,8 +1621,6 @@ bool Theory::isZero(TermList term) */ bool Theory::isInterpretedFunction(Term* t) { - CALL("Theory::isInterpretedFunction(Term*)"); - return isInterpretedFunction(t->functor()); } @@ -1751,8 +1629,6 @@ bool Theory::isInterpretedFunction(Term* t) */ bool Theory::isInterpretedFunction(TermList t) { - CALL("Theory::isInterpretedFunction(TermList)"); - return t.isTerm() && isInterpretedFunction(t.term()); } @@ -1762,7 +1638,6 @@ bool Theory::isInterpretedFunction(TermList t) */ bool Theory::isInterpretedFunction(unsigned f, Interpretation itp) { - CALL("Theory::isInterpretedFunction(unsigned,Interpretation)"); return isInterpretedFunction(f) && interpretFunction(f)==itp; } /** @@ -1771,8 +1646,6 @@ bool Theory::isInterpretedFunction(unsigned f, Interpretation itp) */ bool Theory::isInterpretedFunction(Term* t, Interpretation itp) { - CALL("Theory::isInterpretedFunction(Term*,Interpretation)"); - return isInterpretedFunction(t->functor(), itp); } @@ -1782,15 +1655,12 @@ bool Theory::isInterpretedFunction(Term* t, Interpretation itp) */ bool Theory::isInterpretedFunction(TermList t, Interpretation itp) { - CALL("Theory::isInterpretedFunction(TermList,Interpretation)"); - return t.isTerm() && isInterpretedFunction(t.term(), itp); } Interpretation Theory::interpretFunction(unsigned func) { - CALL("Theory::interpretFunction"); ASS(isInterpretedFunction(func)); Signature::InterpretedSymbol* sym = @@ -1804,7 +1674,6 @@ Interpretation Theory::interpretFunction(unsigned func) */ Interpretation Theory::interpretFunction(Term* t) { - CALL("Theory::interpretFunction"); ASS(isInterpretedFunction(t)); return interpretFunction(t->functor()); @@ -1815,7 +1684,6 @@ Interpretation Theory::interpretFunction(Term* t) */ Interpretation Theory::interpretFunction(TermList t) { - CALL("Theory::interpretFunction"); ASS(t.isTerm()); return interpretFunction(t.term()); @@ -1823,7 +1691,6 @@ Interpretation Theory::interpretFunction(TermList t) Interpretation Theory::interpretPredicate(unsigned pred) { - CALL("Theory::interpretPredicate"); ASS(isInterpretedPredicate(pred)); Signature::InterpretedSymbol* sym = @@ -1838,7 +1705,6 @@ Interpretation Theory::interpretPredicate(unsigned pred) */ Interpretation Theory::interpretPredicate(Literal* lit) { - CALL("Theory::interpretPredicate"); ASS(isInterpretedPredicate(lit->functor())); return interpretPredicate(lit->functor()); @@ -1853,8 +1719,6 @@ Interpretation Theory::interpretPredicate(Literal* lit) */ bool Theory::tryInterpretConstant(const Term* t, IntegerConstantType& res) { - CALL("Theory::tryInterpretConstant(Term*,IntegerConstantType)"); - if (t->numTermArguments() != 0 || t->isSpecial()) { return false; } @@ -1866,7 +1730,6 @@ bool Theory::tryInterpretConstant(const Term* t, IntegerConstantType& res) bool Theory::tryInterpretConstant(unsigned func, IntegerConstantType& res) { Signature::Symbol* sym = env.signature->getFunction(func); - CALL("Theory::tryInterpretConstant(Term*,IntegerConstantType)"); if (!sym->integerConstant()) { return false; } @@ -1885,8 +1748,6 @@ bool Theory::tryInterpretConstant(unsigned func, IntegerConstantType& res) */ bool Theory::tryInterpretConstant(const Term* t, RationalConstantType& res) { - CALL("Theory::tryInterpretConstant(Term*,RationalConstantType)"); - if (t->numTermArguments() != 0 || t->isSpecial()) { return false; } @@ -1897,7 +1758,6 @@ bool Theory::tryInterpretConstant(const Term* t, RationalConstantType& res) bool Theory::tryInterpretConstant(unsigned func, RationalConstantType& res) { Signature::Symbol* sym = env.signature->getFunction(func); - CALL("Theory::tryInterpretConstant(Term*,RationalConstantType)"); if (!sym->rationalConstant()) { return false; } @@ -1915,8 +1775,6 @@ bool Theory::tryInterpretConstant(unsigned func, RationalConstantType& res) */ bool Theory::tryInterpretConstant(const Term* t, RealConstantType& res) { - CALL("Theory::tryInterpretConstant(Term*,RealConstantType)"); - if (t->numTermArguments() != 0 || t->isSpecial()) { return false; } @@ -1927,7 +1785,6 @@ bool Theory::tryInterpretConstant(const Term* t, RealConstantType& res) bool Theory::tryInterpretConstant(unsigned func, RealConstantType& res) { Signature::Symbol* sym = env.signature->getFunction(func); - CALL("Theory::tryInterpretConstant(Term*,RealConstantType)"); if (!sym->realConstant()) { return false; } @@ -1937,32 +1794,24 @@ bool Theory::tryInterpretConstant(unsigned func, RealConstantType& res) Term* Theory::representConstant(const IntegerConstantType& num) { - CALL("Theory::representConstant(const IntegerConstantType&)"); - unsigned func = env.signature->addIntegerConstant(num); return Term::create(func, 0, 0); } Term* Theory::representConstant(const RationalConstantType& num) { - CALL("Theory::representConstant(const RationalConstantType&)"); - unsigned func = env.signature->addRationalConstant(num); return Term::create(func, 0, 0); } Term* Theory::representConstant(const RealConstantType& num) { - CALL("Theory::representConstant(const RealConstantType&)"); - unsigned func = env.signature->addRealConstant(num); return Term::create(func, 0, 0); } Term* Theory::representIntegerConstant(vstring str) { - CALL("Theory::representIntegerConstant"); - try { return Theory::instance()->representConstant(IntegerConstantType(str)); } @@ -1982,7 +1831,6 @@ Term* Theory::representIntegerConstant(vstring str) Term* Theory::representRealConstant(vstring str) { - CALL("Theory::representRealConstant"); try { return Theory::instance()->representConstant(RealConstantType(str)); } catch(ArithmeticException&) { @@ -1996,7 +1844,6 @@ Term* Theory::representRealConstant(vstring str) */ void Theory::registerLaTeXPredName(unsigned pred, bool polarity, vstring temp) { - CALL("Theory::registerPredLaTeXName"); if(polarity){ _predLaTeXnamesPos.insert(pred,temp); }else{ @@ -2009,7 +1856,6 @@ void Theory::registerLaTeXPredName(unsigned pred, bool polarity, vstring temp) */ void Theory::registerLaTeXFuncName(unsigned func, vstring temp) { - CALL("Theory::registerFuncLaTeXName"); _funcLaTeXnames.insert(func,temp); } @@ -2122,8 +1968,6 @@ std::ostream& operator<<(std::ostream& out, Kernel::Theory::Interpretation const */ vstring Theory::tryGetInterpretedLaTeXName(unsigned func, bool pred,bool polarity) { - CALL("Theory::tryGetInterpretedLaTeXName"); - //cout << "Get LaTeX for " << func << endl; // Used if no recorded template is found diff --git a/Kernel/Theory.hpp b/Kernel/Theory.hpp index 3a97ffadd..c61343e0d 100644 --- a/Kernel/Theory.hpp +++ b/Kernel/Theory.hpp @@ -423,8 +423,6 @@ class Theory Interpretation interpretationFromIndexedInterpretation(IndexedInterpretation ii, unsigned index) { - CALL("inpretationFromIndexedInterpretation"); - ConcreteIndexedInterpretation cii = std::make_pair(ii,index); Interpretation res; @@ -519,7 +517,6 @@ class Theory */ bool tryInterpretConstant(TermList trm, IntegerConstantType& res) { - CALL("Theory::tryInterpretConstant(TermList,IntegerConstantType)"); if (!trm.isTerm()) { return false; } @@ -534,7 +531,6 @@ class Theory */ bool tryInterpretConstant(TermList trm, RationalConstantType& res) { - CALL("Theory::tryInterpretConstant(TermList,RationalConstantType)"); if (!trm.isTerm()) { return false; } @@ -549,7 +545,6 @@ class Theory */ bool tryInterpretConstant(TermList trm, RealConstantType& res) { - CALL("Theory::tryInterpretConstant(TermList,RealConstantType)"); if (!trm.isTerm()) { return false; } diff --git a/Kernel/Unit.cpp b/Kernel/Unit.cpp index 250435de0..a356b3cce 100644 --- a/Kernel/Unit.cpp +++ b/Kernel/Unit.cpp @@ -16,7 +16,6 @@ #include "Forwards.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" #include "Lib/Int.hpp" @@ -45,7 +44,6 @@ unsigned Unit::_lastParsingNumber = 0; */ void Unit::onPreprocessingEnd() { - CALL("Unit::onPreprocessingEnd"); ASS(!_firstNonPreprocessingNumber); _firstNonPreprocessingNumber=_lastNumber+1; @@ -62,7 +60,6 @@ Unit::Unit(Kind kind,const Inference& inf) void Unit::incRefCnt() { - CALL("Unit::incRefCnt"); if(isClause()) { static_cast(this)->incRefCnt(); } @@ -70,14 +67,12 @@ void Unit::incRefCnt() void Unit::decRefCnt() { - CALL("Unit::decRefCnt"); if(isClause()) { static_cast(this)->decRefCnt(); } } Clause* Unit::asClause() { - CALL("Unit::asClause"); ASS(isClause()); return static_cast(this); } @@ -85,8 +80,6 @@ Clause* Unit::asClause() { Color Unit::getColor() { - CALL("Unit::getColor"); - if(isClause()) { return static_cast(this)->color(); } @@ -97,8 +90,6 @@ Color Unit::getColor() unsigned Unit::getWeight() { - CALL("Unit::getWeight"); - if(isClause()) { return static_cast(this)->weight(); } @@ -109,8 +100,6 @@ unsigned Unit::getWeight() void Unit::destroy() { - CALL("Unit::destroy"); - if(isClause()) { static_cast(this)->destroy(); } @@ -121,8 +110,6 @@ void Unit::destroy() vstring Unit::toString() const { - CALL("Unit::toString"); - if(isClause()) { return static_cast(this)->toString(); } @@ -133,8 +120,6 @@ vstring Unit::toString() const unsigned Unit::varCnt() { - CALL("Unit::varCnt"); - if(isClause()) { return static_cast(this)->varCnt(); } @@ -166,8 +151,6 @@ Formula* Unit::getFormula() */ vstring Unit::inferenceAsString() const { - CALL("Unit::inferenceAsString"); - #if 1 InferenceStore& infS = *InferenceStore::instance(); @@ -206,8 +189,6 @@ vstring Unit::inferenceAsString() const void Unit::assertValid() { - CALL("Unit::assertValid"); - if(isClause()) { ASS_ALLOC_TYPE(this,"Clause"); } @@ -219,8 +200,6 @@ void Unit::assertValid() // TODO this could be more efficient. Although expected cost is log(n) where n is length of proof bool Unit::derivedFromInput() const { - CALL("Unit::derivedFromInput"); - // Depth-first search of derivation - it's likely that we'll hit an input clause as soon // as we hit the top Stack todo; @@ -242,8 +221,6 @@ typedef List InferenceList; // TODO this could be more efficient. Although expected cost is log(n) where n is length of proof bool Unit::derivedFromGoalCheck() const { - CALL("Unit::derivedFromGoalCheck"); - // Breadth-first search of derivation - it's likely that we'll hit a goal-related node // close to the refutation... unless it doesn't exist of course InferenceList* todo = InferenceList::empty(); diff --git a/Lib/Allocator.cpp b/Lib/Allocator.cpp index de0c3df5e..cec2d0968 100644 --- a/Lib/Allocator.cpp +++ b/Lib/Allocator.cpp @@ -73,7 +73,6 @@ unsigned watchAddressLastValue = 0; #endif #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Shell/Statistics.hpp" @@ -115,8 +114,6 @@ unsigned Allocator::_tolerantZone = 1; // starts > 0; we are not checking by def */ string Lib::___prettyFunToClassName(std::string str) { - CALLC("___prettyFunToClassName",MAKE_CALLS); - string noPref = str.substr(19); size_t fnNamePos = noPref.find("::className()"); string className = noPref.substr(0,fnNamePos); @@ -143,8 +140,6 @@ void Allocator::operator delete(void* obj) { */ Allocator::Allocator() { - CALLC("Allocator::Allocator",MAKE_CALLS); - #if ! USE_SYSTEM_ALLOCATION for (int i = REQUIRES_PAGE/4-1;i >= 0;i--) { _freeList[i] = 0; @@ -162,8 +157,6 @@ Allocator::Allocator() */ Lib::Allocator::~Allocator () { - CALLC("Allocator::~Allocator",MAKE_CALLS); - while (_myPages) { deallocatePages(_myPages); } @@ -175,8 +168,6 @@ Lib::Allocator::~Allocator () */ void Allocator::initialise() { - CALLC("Allocator::initialise",MAKE_CALLS) - #if VDEBUG Descriptor::map = 0; Descriptor::afterLast = 0; @@ -201,8 +192,6 @@ void Allocator::initialise() */ void Allocator::addressStatus(const void* address) { - CALLC("Allocator::addressStatus",MAKE_CALLS); - Descriptor* pg = 0; // page descriptor cout << "Status of address " << address << '\n'; @@ -276,7 +265,6 @@ void Allocator::reportUsageByClasses() */ void Allocator::cleanup() { - CALLC("Allocator::cleanup",MAKE_CALLS); BYPASSING_ALLOCATOR; #if !LEAK_ALLOCATOR @@ -348,7 +336,6 @@ void Allocator::deallocateKnown(void* obj,size_t size,const char* className) void Allocator::deallocateKnown(void* obj,size_t size) #endif { - CALLC("Allocator::deallocateKnown",MAKE_CALLS); ASS(obj); TimeoutProtector tp; @@ -424,8 +411,6 @@ void Allocator::deallocateUnknown(void* obj,const char* className) void Allocator::deallocateUnknown(void* obj) #endif { - CALLC("Allocator::deallocateUnknown",MAKE_CALLS); - TimeoutProtector tp; #if VDEBUG @@ -502,8 +487,6 @@ void* Allocator::reallocateUnknown(void* obj, size_t newsize, const char* classN void* Allocator::reallocateUnknown(void* obj, size_t newsize) #endif { - CALLC("Allocator::reallocateUnknown",MAKE_CALLS); - // cout << "reallocateUnknown " << obj << " newsize " << newsize << endl; #if VDEBUG @@ -541,7 +524,6 @@ void* Allocator::reallocateUnknown(void* obj, size_t newsize) */ Allocator* Allocator::newAllocator() { - CALLC("Allocator::newAllocator",MAKE_CALLS); BYPASSING_ALLOCATOR; #if VDEBUG && USE_SYSTEM_ALLOCATION @@ -563,7 +545,6 @@ Allocator* Allocator::newAllocator() */ Allocator::Page* Allocator::allocatePages(size_t size) { - CALLC("Allocator::allocatePages",MAKE_CALLS); ASS(size >= 0); #if VDEBUG && USE_SYSTEM_ALLOCATION @@ -707,8 +688,6 @@ void Allocator::deallocatePages(Page* page) #if VDEBUG && USE_SYSTEM_ALLOCATION ASSERTION_VIOLATION; #else - CALLC("Allocator::deallocatePages",MAKE_CALLS); - #if VDEBUG Descriptor* desc = Descriptor::find(page); desc->timestamp = ++Descriptor::globalTimestamp; @@ -776,7 +755,6 @@ void* Allocator::allocateKnown(size_t size,const char* className) void* Allocator::allocateKnown(size_t size) #endif { - CALLC("Allocator::allocateKnown",MAKE_CALLS); ASS(size > 0); TimeoutProtector tp; @@ -831,8 +809,6 @@ void* Allocator::allocateKnown(size_t size) */ char* Allocator::allocatePiece(size_t size) { - CALLC("Allocator::allocatePiece",MAKE_CALLS); - char* result; #if USE_SYSTEM_ALLOCATION // result = new char[size]; @@ -899,7 +875,6 @@ void* Allocator::allocateUnknown(size_t size,const char* className) void* Allocator::allocateUnknown(size_t size) #endif { - CALLC("Allocator::allocateUnknown",MAKE_CALLS); ASS(size>0); TimeoutProtector tp; @@ -957,8 +932,7 @@ void* Allocator::allocateUnknown(size_t size) * @since 14/12/2005 Bellevue */ Allocator::Descriptor* Allocator::Descriptor::find (const void* addr) -{ - CALLC("Allocator::Descriptor::find",MAKE_CALLS); +{ BYPASSING_ALLOCATOR; if (noOfEntries >= maxEntries) { // too many entries @@ -1023,8 +997,6 @@ Allocator::Descriptor* Allocator::Descriptor::find (const void* addr) * @since 12/08/2014 Manchester */ ostream& Lib::operator<<(ostream& out, const Allocator::Descriptor& d) { - CALLC("operator<<(ostream,Allocator::Descriptor)",MAKE_CALLS); - out << (size_t)(&d) << " [address:" << d.address << ",timestamp:" << d.timestamp @@ -1058,7 +1030,6 @@ Allocator::Descriptor::Descriptor () known(0), page(0) { -// CALL("Allocator::Descriptor::Descriptor"); } // Allocator::Descriptor::Descriptor Allocator::Descriptor::~Descriptor() {} @@ -1069,8 +1040,6 @@ Allocator::Descriptor::~Descriptor() {} */ unsigned Allocator::Descriptor::hash (const void* addr) { - CALLC("Allocator::Descriptor::hash",MAKE_CALLS); - char* val = reinterpret_cast(&addr); unsigned hash = FNV32_OFFSET_BASIS; for (int i = sizeof(void*)-1;i >= 0;i--) { @@ -1181,7 +1150,6 @@ struct Mem */ void testAllocator() { - CALLC("testAllocator",MAKE_CALLS); // Random::setSeed(1); cout << "Testing the Allocator class...\n"; diff --git a/Lib/Allocator.hpp b/Lib/Allocator.hpp index 5d3e62420..9c30a109b 100644 --- a/Lib/Allocator.hpp +++ b/Lib/Allocator.hpp @@ -22,7 +22,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Portability.hpp" @@ -30,8 +29,6 @@ #include #endif -#define MAKE_CALLS 0 - #define USE_PRECISE_CLASS_NAMES 0 /** Page size in bytes */ @@ -66,7 +63,6 @@ */ template void checked_delete(T * x) { - CALL("checked_delete"); // intentionally complex - simplification causes regressions typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; (void) sizeof(type_must_be_complete); @@ -87,19 +83,16 @@ class Allocator { /** Return the amount of used memory */ static size_t getUsedMemory() { - CALLC("Allocator::getUsedMemory",MAKE_CALLS); return _usedMemory; } /** Return the global memory limit (in bytes) */ static size_t getMemoryLimit() { - CALLC("Allocator::getMemoryLimit",MAKE_CALLS); return _memoryLimit; } /** Set the global memory limit (in bytes) */ static void setMemoryLimit(size_t size) { - CALLC("Allocator::setMemoryLimit",MAKE_CALLS); _memoryLimit = size; _tolerated = size + (size/10); } @@ -128,8 +121,6 @@ class Allocator { /** Initialise the static allocator's methods */ Initialiser() { - CALLC("Allocator::Initialiser::Initialiser",MAKE_CALLS); - if (Allocator::_initialised++ == 0) { Allocator::initialise(); } @@ -137,7 +128,6 @@ class Allocator { ~Initialiser() { - CALLC("Allocator::Initialiser::~Initialiser",MAKE_CALLS); if (--Allocator::_initialised == 0) { Allocator::cleanup(); } @@ -356,7 +346,6 @@ static Allocator::Initialiser _____; template T* array_new(void* placement, size_t length) { - CALLC("array_new",MAKE_CALLS); ASS_NEQ(placement,0); ASS_G(length,0); @@ -378,7 +367,6 @@ T* array_new(void* placement, size_t length) template void array_delete(T* array, size_t length) { - CALLC("array_delete",MAKE_CALLS); ASS_NEQ(array,0); ASS_G(length,0); diff --git a/Lib/Array.hpp b/Lib/Array.hpp index 2c5f280f8..0048da1ab 100644 --- a/Lib/Array.hpp +++ b/Lib/Array.hpp @@ -105,8 +105,6 @@ class Array */ virtual ~Array() { - CALL("Array::~Array()"); - if(_array) { array_delete(_array, _capacity); DEALLOC_KNOWN(_array,_capacity*sizeof(C),"Array<>"); @@ -201,7 +199,6 @@ class Array */ void expandToFit (size_t n) { - CALL("Array::expandToFit"); ASS(n >= _capacity); // determine new capacity (at least double the old one) diff --git a/Lib/ArrayMap.hpp b/Lib/ArrayMap.hpp index 7413471a3..46859d7d4 100644 --- a/Lib/ArrayMap.hpp +++ b/Lib/ArrayMap.hpp @@ -110,8 +110,6 @@ class ArrayMap inline void insert(size_t index, T obj=T()) { - CALL("ArrayMap::insert"); - Entry& e=(*this)[index]; ASS_NEQ(e._timestamp,_timestamp); e._obj=obj; @@ -127,8 +125,6 @@ class ArrayMap inline void set(size_t index, T obj=T()) { - CALL("ArrayMap::set"); - Entry& e=(*this)[index]; e._obj=obj; e._timestamp=_timestamp; @@ -141,7 +137,6 @@ class ArrayMap inline T get(size_t index) { - CALL("ArrayMap::get"); ASS_EQ((*this)[index]._timestamp,_timestamp); return (*this)[index]._obj; } @@ -152,7 +147,6 @@ class ArrayMap inline T get(size_t index, T def) { - CALL("ArrayMap::get"); if((*this)[index]._timestamp!=_timestamp) { return def; } @@ -168,7 +162,6 @@ class ArrayMap inline bool find(size_t index) { - CALL("ArrayMap::find"); return (*this)[index]._timestamp==_timestamp; } @@ -183,7 +176,6 @@ class ArrayMap inline bool find(size_t index, T& val) { - CALL("ArrayMap::find"); if((*this)[index]._timestamp==_timestamp) { val = (*this)[index]._obj; return true; @@ -198,7 +190,6 @@ class ArrayMap inline void remove(size_t index) { - CALL("ArrayMap::remove"); ASS((*this)[index]._timestamp==_timestamp); (*this)[index]._timestamp=0; } @@ -211,8 +202,6 @@ class ArrayMap inline bool getValuePtr(size_t index, T*& pObj, T init) { - CALL("ArrayMap::getValuePtr"); - Entry& e=(*this)[index]; pObj=&e._obj; if(e._timestamp!=_timestamp) { @@ -242,7 +231,6 @@ class ArrayMap size_t next() { - CALL("ArrayMap::KeyIterator::next"); ASS_L(_idx,_parent.size()); ASS_EQ(_parent[_idx]._timestamp,_parent._timestamp); return _idx++; @@ -273,8 +261,6 @@ class ArraySet : public ArrayMap template void insertFromIterator(It it) { - CALL("ArraySet::insertFromIterator"); - while(it.hasNext()) { insert(it.next()); } diff --git a/Lib/Backtrackable.hpp b/Lib/Backtrackable.hpp index 01b749c80..bd9527350 100644 --- a/Lib/Backtrackable.hpp +++ b/Lib/Backtrackable.hpp @@ -84,8 +84,6 @@ class BacktrackData */ void backtrack() { - CALL("BacktrackData::backtrack"); - BacktrackObject* curr=_boList; BacktrackObject* next; while(curr) { @@ -104,8 +102,6 @@ class BacktrackData */ void drop() { - CALL("BacktrackData::drop"); - BacktrackObject* curr=_boList; BacktrackObject* next; while(curr) { @@ -123,8 +119,6 @@ class BacktrackData */ void addBacktrackObject(BacktrackObject* bo) { - CALL("BacktrackData::addBacktrackObject"); - ASS_EQ(bo->_next,0); bo->_next=_boList; _boList=bo; @@ -136,8 +130,6 @@ class BacktrackData */ void commitTo(BacktrackData& bd) { - CALL("BacktrackData::commitTo"); - if(!_boList) { return; } @@ -166,8 +158,6 @@ class BacktrackData template void backtrackableSet(T* ptr, T val) { - CALL("BacktrackData::backtrackableSet"); - addBacktrackObject(new SetValueBacktrackObject(ptr,*ptr)); *ptr=val; } @@ -175,8 +165,6 @@ class BacktrackData #if VDEBUG vstring toString() { - CALL("BacktrackData::toString"); - vstring res; unsigned cnt=0; BacktrackObject* bobj=_boList; @@ -302,7 +290,6 @@ class Backtrackable */ void bdCommit(BacktrackData& bd) { - CALL("Backtrackable::bdCommit"); ASS(!bdIsRecording() || &bd!=&bdGet()); if(bdIsRecording()) { @@ -336,7 +323,6 @@ class Backtrackable */ void bdAdd(BacktrackObject* bo) { - CALL("Backtrackable::bdAdd"); ASS(bdIsRecording()); bdGet().addBacktrackObject(bo); @@ -348,7 +334,6 @@ class Backtrackable */ BacktrackData& bdGet() { - CALL("Backtrackable::bdGet"); ASS(bdIsRecording()); return *_bdStack->head(); diff --git a/Lib/BiMap.hpp b/Lib/BiMap.hpp index 4009725b1..012fcb0af 100644 --- a/Lib/BiMap.hpp +++ b/Lib/BiMap.hpp @@ -53,7 +53,6 @@ class BiMap : Map, Map { template B& getOrInit(A key, InitFn init) { - CALL("Map::getOrInit"); return Into::getOrInit(key, [&]() { auto val = init(); From::insert(val, key); diff --git a/Lib/BinaryHeap.hpp b/Lib/BinaryHeap.hpp index bc501e5cd..a341e4cdf 100644 --- a/Lib/BinaryHeap.hpp +++ b/Lib/BinaryHeap.hpp @@ -52,7 +52,6 @@ class BinaryHeap /** Deallocate the BinaryHeap */ ~BinaryHeap() { - CALL("BinaryHeap::~BinaryHeap"); if(_data) { T* ep=_data+_size; while(ep!=_data1) { @@ -93,7 +92,6 @@ class BinaryHeap inline void insert(T obj) { - CALL("BinaryHeap::insert"); ensureAvaiablePosition(); _size++; ::new (&_data1[_size]) T(obj); @@ -112,7 +110,6 @@ class BinaryHeap inline T pop() { - CALL("BinaryHeap::pop"); ASS(!isEmpty()); T res=_data[0]; _size--; @@ -129,7 +126,6 @@ class BinaryHeap inline T popWithAllEqual() { - CALL("BinaryHeap::pop"); T res=pop(); while(!isEmpty() && Comparator::compare(res, top())==EQUAL) { pop(); @@ -139,7 +135,6 @@ class BinaryHeap T backtrackablePop(unsigned& lastBubbleIndex) { - CALL("BinaryHeap::backtrackablePop(unsigned&)"); ASS(!isEmpty()); T res=_data[0]; _size--; @@ -155,7 +150,6 @@ class BinaryHeap inline T backtrackablePop(BacktrackData& bd) { - CALL("BinaryHeap::backtrackablePop(BacktrackData&)"); unsigned lastBubbleIndex; T res=backtrackablePop(lastBubbleIndex); bd.addBacktrackObject( @@ -165,7 +159,6 @@ class BinaryHeap unsigned backtrackableInsert(T obj) { - CALL("BinaryHeap::backtrackableInsert(T,unsigned&)"); ensureAvaiablePosition(); _size++; ::new (&_data1[_size]) T(obj); @@ -174,7 +167,6 @@ class BinaryHeap inline void backtrackableInsert(T obj, BacktrackData& bd) { - CALL("BinaryHeap::backtrackableInsert(T,BacktrackData&)"); unsigned lastBubbleIndex=backtrackableInsert(obj); bd.addBacktrackObject( new BHInsertBacktrackObject(this, lastBubbleIndex)); @@ -272,7 +264,6 @@ class BinaryHeap * at @b index wrt its ancestors, and return its new index. */ unsigned bubbleUp(unsigned index) { - CALL("BinaryHeap::bubbleUp"); ASS(index>0 && index<=_size); unsigned nextIndex=index>>1; while(nextIndex) { @@ -291,7 +282,6 @@ class BinaryHeap * at @b index wrt its descendants, and return its new index. */ unsigned bubbleDown(unsigned index) { - CALL("BinaryHeap::bubbleDown"); ASS(index>0 && index<=_size); unsigned nextIndex=index<<1; while(nextIndex<=_size) { @@ -329,8 +319,6 @@ class BinaryHeap */ void expand() { - CALL("BinaryHeap::expand"); - ASS(_capacity==_size); unsigned oldCapacity=_capacity; diff --git a/Lib/Coproduct.hpp b/Lib/Coproduct.hpp index f05427909..598990f7b 100644 --- a/Lib/Coproduct.hpp +++ b/Lib/Coproduct.hpp @@ -19,7 +19,6 @@ #define MACRO_EXPANSION true #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Hash.hpp" #include "Lib/TypeList.hpp" #include "Lib/Option.hpp" @@ -311,7 +310,6 @@ class Coproduct #define REF_POLYMORPIHIC(REF, MOVE) \ \ Coproduct(Coproduct REF other) : _tag(other._tag) { \ - CALL("Coproduct(Coproduct " #REF " other)") \ ASS_REP(other._tag <= size, other._tag); \ CoproductImpl::InitDynamicTag<0, size, Ts>{}(_content, other._tag, MOVE(other._content)); \ } \ @@ -364,7 +362,6 @@ class Coproduct } \ \ Coproduct &operator=(Coproduct REF other) { \ - CALL("Coproduct& operator=(Coproduct " #REF "other)") \ ASS_REP(other._tag <= size, other._tag); \ _content.destroy(_tag); \ CoproductImpl::InitDynamicTag<0, size, Ts>{}(_content, other._tag, MOVE(other._content)); \ @@ -388,7 +385,6 @@ class Coproduct */ \ template \ inline TL::Get REF unwrap() REF { \ - CALL("Coproduct::unwrap() " #REF ); \ static_assert(idx < size, "out of bounds"); \ ASS_EQ(idx, _tag); \ return CoproductImpl::Unwrap{}(MOVE(_content)); \ @@ -462,7 +458,6 @@ template struct CoproductOrdering template bool operator()(Coproduct const& lhs, Coproduct const& rhs) const { - CALL("CoproductOrdering::operator()(Coproduct const&, Coproduct const&)") if (lhs._tag < rhs._tag) return true; if (lhs._tag > rhs._tag) return false; diff --git a/Lib/DArray.hpp b/Lib/DArray.hpp index c19d46c7c..ec0271c4a 100644 --- a/Lib/DArray.hpp +++ b/Lib/DArray.hpp @@ -57,8 +57,6 @@ class DArray DArray (size_t size=0) : _size(size), _capacity(size) { - CALL("DArray::DArray"); - if(size>0) { void* mem = ALLOC_KNOWN(sizeof(C)*_capacity,"DArray<>"); _array = array_new(mem, _capacity); @@ -70,8 +68,6 @@ class DArray DArray(const DArray& o) : _size(o.size()), _capacity(o.size()) { - CALL("DArray::DArray(const DArray&)"); - if(_size==0) { _array=0; return; @@ -87,8 +83,6 @@ class DArray /** Delete array */ inline ~DArray() { - CALL("DArray::~DArray"); - if(_array) { array_delete(_array, _capacity); DEALLOC_KNOWN(_array,sizeof(C)*_capacity,"DArray<>"); @@ -98,8 +92,6 @@ class DArray /** Return a reference to the n-th element of the array */ inline C& operator[] (size_t n) { - CALL("DArray::operator[]"); - ASS_L(n,_size); return _array[n]; } // operator[] @@ -107,8 +99,6 @@ class DArray /** Return a reference to the n-th element of the array */ inline const C& operator[](size_t n) const { - CALL("DArray::operator[] const"); - ASS_L(n,_size); return _array[n]; } @@ -118,7 +108,6 @@ class DArray */ inline void shrink(size_t s) { - CALL("DArray::shrink"); ASS_LE(s,_size); _size = s; @@ -126,7 +115,6 @@ class DArray inline bool operator==(const DArray& o) const { - CALL("DArray::operator=="); if(size()!=o.size()) { return false; } size_t sz = size(); for(size_t i=0; i= s) { _size = s; return true; @@ -187,8 +173,6 @@ class DArray */ void expand(size_t s) { - CALL("DArray::expand"); - if (_capacity >= s) { _size = s; return; @@ -232,8 +216,6 @@ class DArray */ void expand(size_t s, C defVal) { - CALL("DArray::expand/2"); - size_t oldSize = _size; expand(s); @@ -251,7 +233,6 @@ class DArray /** Creates a new array that is initialized with @b value on every position */ static DArray initialized(size_t count, const C& value=C()) { - CALL("DArray::initialized"); DArray out(count); out.init(count, value); return out; @@ -260,8 +241,6 @@ class DArray /** Ensure that the array's size is at least @b count and * initialize first @b count elements of the array to @b value. */ void init(size_t count, const C& value=C()) { - CALL("DArray::init"); - ensure(count); C* ptr=_array+count; while(ptr!=_array) { @@ -277,8 +256,6 @@ class DArray */ template void initFromArray(size_t count, const Arr& src) { - CALL("DArray::initFromArray"); - ensure(count); C* ptr=_array+count; while(count) { @@ -286,8 +263,6 @@ class DArray } } void initFromArray(size_t count, const C* src) { - CALL("DArrayTKV::initFromArray"); - ensure(count); C* ptr=_array+count; while(count) { @@ -301,8 +276,6 @@ class DArray */ template void initFromIterator(It it, size_t count=0) { - CALL("DArray::initFromIterator"); - if(count) { ensure(count); C* ptr=_array; @@ -321,8 +294,6 @@ class DArray template static DArray fromIterator(It it, size_t count=0) { - CALL("DArray::fromIterator"); - DArray out; if (count != 0) { out.initFromIterator(it, count); @@ -354,8 +325,6 @@ class DArray template void sortGen(Comparator comp) { - CALL("DArray::sortGen"); - if(_size <= 1) { return; } diff --git a/Lib/DHMap.hpp b/Lib/DHMap.hpp index 36edf96dd..7ad35e62e 100644 --- a/Lib/DHMap.hpp +++ b/Lib/DHMap.hpp @@ -112,7 +112,6 @@ class DHMap /** Empty the DHMap */ void reset() { - CALL("DHMap::reset"); unsigned oldTS=_timestamp; _timestamp++; _size=0; @@ -138,7 +137,6 @@ class DHMap inline bool find(Key key, Val& val) const { - CALL("DHMap::find/2"); const Entry* e=findEntry(key); if(!e) { return false; @@ -154,7 +152,6 @@ class DHMap */ Val* findPtr(Key key) { - CALL("DHMap::findPtr"); Entry* e=findEntry(key); if(!e) { return nullptr; @@ -168,7 +165,6 @@ class DHMap inline bool find(Key key) const { - CALL("DHMap::find/1"); return findEntry(key); } @@ -239,7 +235,6 @@ class DHMap /** same as @b insert but using move semantics instead of copying */ bool emplace(Key key, Val&& val) { - CALL("DHMap::emplace"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -269,7 +264,6 @@ class DHMap */ bool insert(Key key, const Val& val) { - CALL("DHMap::insert"); return emplace(key, Val(val)); } @@ -279,7 +273,6 @@ class DHMap */ Val findOrInsert(Key key, const Val& val) { - CALL("DHMap::insert"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -308,7 +301,6 @@ class DHMap */ bool findOrInsert(Key key, Val& val, const Val& initial) { - CALL("DHMap::insert"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -338,7 +330,6 @@ class DHMap */ bool getValuePtr(Key key, Val*& pval, const Val& initial) { - CALL("DHMap::getValuePtr/3"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -368,7 +359,6 @@ class DHMap */ bool getValuePtr(Key key, Val*& pval) { - CALL("DHMap::getValuePtr/2"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -398,7 +388,6 @@ class DHMap */ bool set(Key key, const Val& val) { - CALL("DHMap::set"); ensureExpanded(); Entry* e=findEntryToInsert(key); bool exists = e->_info.timestamp==_timestamp && !e->_info.deleted; @@ -429,7 +418,6 @@ class DHMap inline bool pop(Key key, Val& val) { - CALL("DHMap::pop"); Entry* e=findEntry(key); if(!e) { return false; @@ -448,7 +436,6 @@ class DHMap */ bool remove(Key key) { - CALL("DHMap::remove"); Entry* e=findEntry(key); if(!e) { return false; @@ -532,8 +519,6 @@ class DHMap /** Expand DHMap to about double of its current size */ void expand() { - CALL("DHMap::expand"); - if(_capacityIndex>=DHMAP_MAX_CAPACITY_INDEX) { throw Exception("Lib::DHMap::expand: MaxCapacityIndex reached."); } @@ -586,7 +571,6 @@ class DHMap * or 0, if there is no such */ const Entry* findEntry(Key key) const { - CALL("DHMap::findEntry"); if (_capacity == 0) return nullptr; ASS(_capacity>_size+_deleted); @@ -629,7 +613,6 @@ class DHMap * specified key */ Entry* findEntryToInsert(Key key) { - CALL("DHMap::findEntryToInsert"); ensureExpanded(); ASS(_capacity>_size+_deleted); @@ -687,7 +670,6 @@ class DHMap */ bool hasNext() { - CALL("DHMap::DomainIteratorCore::hasNext"); while (_next != _last) { if (_next->_info.timestamp==_timestamp && !_next->_info.deleted) { return true; @@ -704,7 +686,6 @@ class DHMap inline Entry* next() { - CALL("DHMap::DomainIteratorCore::next"); ASS(_next != _last); ASS(_next->_info.timestamp==_timestamp && !_next->_info.deleted); return _next++; @@ -882,14 +863,12 @@ class DHMap inline Key nextKey() { return getNextEntry()->_key; } void del() { - CALL("DHMap::DelIterator::del"); _curr->_info.deleted=1; _map._size--; _map._deleted++; } void setValue(Val val) { - CALL("DHMap::DelIterator::setValue"); _curr->_val = val; } diff --git a/Lib/DHMultiset.hpp b/Lib/DHMultiset.hpp index f69c393f8..ac3fcf49d 100644 --- a/Lib/DHMultiset.hpp +++ b/Lib/DHMultiset.hpp @@ -78,7 +78,6 @@ class DHMultiset inline bool find(Val val) const { - CALL("DHMultiset::find/1"); const Entry* e=findEntry(val); return e; } @@ -89,7 +88,6 @@ class DHMultiset inline unsigned multiplicity(Val val) const { - CALL("DHMultiset::find/1"); const Entry* e=findEntry(val); return e ? e->_info.multiplicity : 0; } @@ -109,7 +107,6 @@ class DHMultiset */ int insert(Val val, int multiplicity) { - CALL("DHMultiset::insert"); ASS(multiplicity>0 && ((unsigned)multiplicity)=DHMULTISET_MAX_CAPACITY_INDEX) { throw Exception("Lib::DHMultiset::expand: MaxCapacityIndex reached."); } @@ -295,7 +288,6 @@ class DHMultiset * or 0, if there is no such */ const Entry* findEntry(Val val) const { - CALL("DHMultiset::findEntry"); ASS(_capacity>_size+_deleted); unsigned h1=Hash1::hash(val); @@ -337,7 +329,6 @@ class DHMultiset * specified value */ Entry* findEntryToInsert(Val val) { - CALL("DHMultiset::findEntryToInsert"); ASS(_capacity>_size+_deleted); unsigned h1=Hash1::hash(val); @@ -417,8 +408,6 @@ class DHMultiset */ template void loadFromIterator(It it) { - CALL("DHMultiset::loadFromIterator"); - // TODO check iterator.size() or iterator.sizeHint() while(it.hasNext()) { insert(it.next()); @@ -457,7 +446,6 @@ class DHMultiset */ bool hasNext() { - CALL("DHMultiset::SetIterator::hasNext"); while (_next != _afterLast) { //we don't have to check for _info.deleted, as long as we //set the multiplicity of deleted entries to zero @@ -476,7 +464,6 @@ class DHMultiset inline Val next() { - CALL("DHMultiset::SetIterator::next"); ASS_NEQ(_next, _afterLast); return (_next++)->_val; @@ -489,7 +476,6 @@ class DHMultiset inline Val next(unsigned& multiplicity) { - CALL("DHMultiset::SetIterator::next/1"); ASS_NEQ(_next, _afterLast); multiplicity=_next->_info.multiplicity; @@ -519,7 +505,6 @@ class DHMultiset */ bool hasNext() { - CALL("DHMultiset::Iterator::hasNext"); if(_next->_info.multiplicity > _nextIndex) return true; _nextIndex=0; @@ -542,7 +527,6 @@ class DHMultiset inline Val next() { - CALL("DHMultiset::Iterator::next"); ASS(_next != _afterLast); ASS(_next->_info.multiplicity > _nextIndex); _nextIndex++; diff --git a/Lib/DHSet.hpp b/Lib/DHSet.hpp index c2a094722..1abfe6058 100644 --- a/Lib/DHSet.hpp +++ b/Lib/DHSet.hpp @@ -44,8 +44,6 @@ class DHSet /** Empty the DHSet */ void reset() { - CALL("DHSet::reset"); - _map.reset(); } @@ -55,8 +53,6 @@ class DHSet inline bool find(Val val) const { - CALL("DHSet::find"); - return _map.find(val); } @@ -68,8 +64,6 @@ class DHSet inline bool contains(Val val) const { - CALL("DHSet::contains"); - return find(val); } @@ -79,8 +73,6 @@ class DHSet */ bool insert(Val val) { - CALL("DHSet::insert"); - return _map.insert(val, EmptyStruct()); } @@ -91,8 +83,6 @@ class DHSet */ bool remove(Val val) { - CALL("DHSet::remove"); - return _map.remove(val); } @@ -121,8 +111,6 @@ class DHSet */ template void loadFromIterator(It it) { - CALL("DHSet::loadFromIterator"); - while(it.hasNext()) { insert(it.next()); } @@ -135,8 +123,6 @@ class DHSet */ template void removeIteratorElements(It it) { - CALL("DHSet::removeIteratorElements"); - while(it.hasNext()) { ALWAYS(remove(it.next())); } diff --git a/Lib/Deque.hpp b/Lib/Deque.hpp index 027eed816..4751b601c 100644 --- a/Lib/Deque.hpp +++ b/Lib/Deque.hpp @@ -18,7 +18,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "Reflection.hpp" @@ -48,7 +47,6 @@ class Deque explicit Deque (size_t initialCapacity=8) : _capacity(initialCapacity) { - CALL("Deque::Deque"); ASS_G(initialCapacity,1); void* mem = ALLOC_KNOWN(_capacity*sizeof(C),"Deque<>"); @@ -63,8 +61,6 @@ class Deque */ inline ~Deque() { - CALL("Stack::~Stack"); - C* p=_back; while(p!=_front) { if(p==_data) { @@ -123,8 +119,6 @@ class Deque inline void setFront(C elem) { - CALL("Deuqe::setFront"); - front() = elem; } @@ -154,8 +148,6 @@ class Deque inline void push_back(C elem) { - CALL("Deque::push_back"); - if(shouldExpand()) { expand(); } @@ -175,8 +167,6 @@ class Deque inline void push_front(C elem) { - CALL("Deque::push_front"); - if(shouldExpand()) { expand(); } @@ -197,7 +187,6 @@ class Deque inline C pop_front() { - CALL("Deque::pop_front"); ASS(isNonEmpty()); C res=*_front; @@ -217,7 +206,6 @@ class Deque inline C& back() const { - CALL("Deque::back"); ASS(isNonEmpty()); C* res = _back; @@ -235,7 +223,6 @@ class Deque inline C pop_back() { - CALL("Deque::pop_back"); ASS(isNonEmpty()); if(_back==_data) { @@ -271,8 +258,6 @@ class Deque */ template void pushBackFromIterator(It it) { - CALL("Deque::pushBackFromIterator"); - while(it.hasNext()) { push_back(it.next()); } @@ -283,8 +268,6 @@ class Deque */ template void pushFrontFromIterator(It it) { - CALL("Deque::pushFrontFromIterator"); - while(it.hasNext()) { push_front(it.next()); } @@ -456,8 +439,6 @@ class Deque */ void expand () { - CALL("Deque::expand"); - ASS(shouldExpand()); size_t curSize=size(); diff --git a/Lib/DynamicHeap.hpp b/Lib/DynamicHeap.hpp index 1f65a961c..915cb451c 100644 --- a/Lib/DynamicHeap.hpp +++ b/Lib/DynamicHeap.hpp @@ -45,7 +45,6 @@ class DynamicHeap { */ void addToEnd(TArg obj) { - CALL("DynamicHeap::addToEnd"); ASS(!contains(obj)); size_t newIdx1 = size()+1; @@ -60,8 +59,6 @@ class DynamicHeap { */ void heapify() { - CALL("DynamicHeap::heapify"); - for (size_t i = (size() >> 1); i > 0; i--) { fixIncrease1(i); } @@ -74,8 +71,6 @@ class DynamicHeap { */ void insert(TArg obj) { - CALL("DynamicHeap::insert"); - addToEnd(obj); size_t newIdx1 = size(); fixDecrease1(newIdx1); @@ -83,7 +78,6 @@ class DynamicHeap { T pop() { - CALL("DynamicHeap::pop"); T res = _heap[0]; T* data1 = getData1(); @@ -103,8 +97,6 @@ class DynamicHeap { void notifyIncrease(TArg obj) { - CALL("DynamicHeap::notifyIncrease"); - size_t idx = _elMap.get(obj); ASS(idx==1 || !isGreater1(idx/2, idx)); //check that we didn't decrease fixIncrease1(idx); @@ -112,8 +104,6 @@ class DynamicHeap { void notifyDecrease(TArg obj) { - CALL("DynamicHeap::notifyDecrease"); - size_t idx = _elMap.get(obj); ASS(idx*2>size() || !isGreater1(idx, idx*2)); //check that we didn't increase ASS(idx*2+1>size() || !isGreater1(idx, idx*2+1)); //check that we didn't increase @@ -122,7 +112,6 @@ class DynamicHeap { TArg top() const { - CALL("DynamicHeap::insert"); ASS(!isEmpty()); return _heap[0]; @@ -130,8 +119,6 @@ class DynamicHeap { bool contains(TArg obj) { - CALL("DynamicHeap::contains"); - return _elMap.find(obj); } @@ -149,7 +136,6 @@ class DynamicHeap { */ void fixDecrease1(size_t idx) { - CALL("DynamicHeap::fixDecrease1"); ASS_G(idx, 0); ASS_LE(idx, size()); @@ -168,7 +154,6 @@ class DynamicHeap { */ void fixIncrease1(size_t idx) { - CALL("DynamicHeap::fixDecrease1"); ASS_G(idx, 0); ASS_LE(idx, size()); @@ -213,7 +198,6 @@ class DynamicHeap { */ bool isGreater1(size_t idxA, size_t idxB) { - CALL("DynamicHeap::isGreater1"); ASS_G(idxA, 0); ASS_LE(idxA, size()); ASS_G(idxB, 0); @@ -228,8 +212,6 @@ class DynamicHeap { */ void swapInHeap1(size_t idxA, size_t idxB) { - CALL("DynamicHeap::swapInHeap1"); - T* data1 = getData1(); swap(data1[idxA], data1[idxB]); _elMap.set(data1[idxA], idxA); diff --git a/Lib/Environment.cpp b/Lib/Environment.cpp index 77d8fae59..13355c0ef 100644 --- a/Lib/Environment.cpp +++ b/Lib/Environment.cpp @@ -14,7 +14,6 @@ * @since 06/05/2007 Manchester */ -#include "Debug/Tracer.hpp" #include "Lib/Sys/SyncPipe.hpp" @@ -80,8 +79,6 @@ Environment::Environment() Environment::~Environment() { - CALL("Environment::~Environment"); - Timer::setLimitEnforcement(false); //in the usual cases the _outputDepth should be zero at this point, but in case of @@ -111,8 +108,6 @@ Environment::~Environment() */ bool Environment::timeLimitReached() const { - CALL("Environment::timeLimitReached"); - if (options->timeLimitInDeciseconds() && timer->elapsedDeciseconds() > options->timeLimitInDeciseconds()) { statistics->terminationReason = Shell::Statistics::TIME_LIMIT; @@ -141,7 +136,6 @@ int Environment::remainingTime() const */ void Environment::beginOutput() { - CALL("Environment::beginOutput"); ASS_GE(_outputDepth,0); _outputDepth++; @@ -155,7 +149,6 @@ void Environment::beginOutput() */ void Environment::endOutput() { - CALL("Environment::endOutput"); ASS_G(_outputDepth,0); _outputDepth--; @@ -175,8 +168,6 @@ void Environment::endOutput() */ bool Environment::haveOutput() { - CALL("Environment::haveOutput"); - return _outputDepth; } @@ -188,7 +179,6 @@ bool Environment::haveOutput() */ ostream& Environment::out() { - CALL("Environment::out"); ASS(_outputDepth); if(_priorityOutput) { @@ -209,7 +199,6 @@ ostream& Environment::out() */ void Environment::setPipeOutput(SyncPipe* pipe) { - CALL("Environment::setPipeOutput"); ASS(!haveOutput()); _pipe=pipe; @@ -217,7 +206,6 @@ void Environment::setPipeOutput(SyncPipe* pipe) void Environment::setPriorityOutput(ostream* stm) { - CALL("Environment::setPriorityOutput"); ASS(!_priorityOutput || !stm); _priorityOutput=stm; diff --git a/Lib/Event.hpp b/Lib/Event.hpp index 6aaf6db18..9041c5b4f 100644 --- a/Lib/Event.hpp +++ b/Lib/Event.hpp @@ -132,8 +132,6 @@ class SingleParamEvent public: void fire(T t) { - CALL("SingleParamEvent::fire"); - HandlerList* hit=_handlers; while(hit) { static_cast(hit->head())->fire(t); diff --git a/Lib/FreshnessGuard.hpp b/Lib/FreshnessGuard.hpp index 6a6404705..cc3a84bbf 100644 --- a/Lib/FreshnessGuard.hpp +++ b/Lib/FreshnessGuard.hpp @@ -37,7 +37,6 @@ class FreshnessGuard { * It makes the object non-fresh. */ void use() { - CALL("FreshnessGuard::use"); ASS(isFresh()); if(!isFresh()) { INVALID_OPERATION("using non-fresh object"); diff --git a/Lib/Hash.hpp b/Lib/Hash.hpp index 6d8c72063..ef1e0ebc8 100644 --- a/Lib/Hash.hpp +++ b/Lib/Hash.hpp @@ -209,7 +209,6 @@ class DefaultHash size_t size, unsigned hash = FNV32_OFFSET_BASIS ) { - CALL("DefaultHash::hashBytes"); for (size_t i = 0; i < size; i++) { hash = (hash ^ val[i]) * FNV32_PRIME; } @@ -220,8 +219,6 @@ class DefaultHash * FNV-1a applied to a NUL-terminated C-style string */ static unsigned hashNulTerminated(const char* val) { - CALL("Hash::hash(const char *)"); - unsigned hash = FNV32_OFFSET_BASIS; while (*val) { hash = (hash ^ *val) * FNV32_PRIME; diff --git a/Lib/Int.cpp b/Lib/Int.cpp index c2c7dd117..31a04daf8 100644 --- a/Lib/Int.cpp +++ b/Lib/Int.cpp @@ -20,7 +20,6 @@ #include #include "Int.hpp" -#include "Debug/Tracer.hpp" using namespace Lib; @@ -124,8 +123,6 @@ vstring Int::toHexString(size_t i) */ bool Int::stringToLong (const char* str,long& result) { - CALL("Int::stringToLong"); - if (! *str) { // empty string return false; } @@ -150,7 +147,6 @@ bool Int::stringToLong (const char* str,long& result) */ bool Int::stringToInt (const vstring& str,int& result) { - CALL("Int::stringToInt"); return stringToInt(str.c_str(),result); } // Int::stringToInt @@ -160,7 +156,6 @@ bool Int::stringToInt (const vstring& str,int& result) */ bool Int::stringToUnsignedInt (const vstring& str,unsigned& result) { - CALL("Int::stringToUnsignedInt"); return stringToUnsignedInt(str.c_str(),result); } // Int::stringToUnsignedInt @@ -171,8 +166,6 @@ bool Int::stringToUnsignedInt (const vstring& str,unsigned& result) */ bool Int::stringToUnsignedInt (const char* str,unsigned& result) { - CALL("Int::stringToUnsignedInt"); - if (! *str) { // empty string return false; } @@ -211,8 +204,6 @@ bool Int::stringToInt (const char* str,int& result) */ bool Int::stringToDouble (const char* str,double& result) { - CALL("Int::stringToDouble"); - errno = 0; char* endptr = 0; result = strtod(str,&endptr); @@ -288,8 +279,6 @@ bool Int::stringToUnsigned64 (const vstring& str,long long unsigned& result) */ bool Int::isInteger(const char* str) { - CALL("Int::isInteger"); - if (*str == '-') { str++; } diff --git a/Lib/Int.hpp b/Lib/Int.hpp index 96aedaec5..d0a300a44 100644 --- a/Lib/Int.hpp +++ b/Lib/Int.hpp @@ -100,8 +100,6 @@ class Int template static unsigned gcd(INT i,INT j) { - CALL("Int::gcd"); - unsigned a=safeAbs(i); unsigned b=safeAbs(j); @@ -126,8 +124,6 @@ class Int template static bool safeUnaryMinus(const INT num, INT& res) { - CALL("Int::safeUnaryMinus"); - if(num == numeric_limits::min()) { return false; } @@ -137,8 +133,6 @@ class Int static unsigned safeAbs(const int num) { - CALL("Int::safeAbs"); - if(num == numeric_limits::min()) { // = -2147483648 return (unsigned)num; // = 2147483648 } @@ -153,8 +147,6 @@ class Int template static bool safePlus(INT arg1, INT arg2, INT& res) { - CALL("Int::safePlus"); - if(arg2<0) { if(numeric_limits::min() - arg2 > arg1) { return false; } } @@ -172,8 +164,6 @@ class Int template static bool safeMinus(INT num, INT sub, INT& res) { - CALL("Int::safeMinus"); - if(sub<0) { if(numeric_limits::max() + sub < num) { return false; } } @@ -186,7 +176,6 @@ class Int template static int sgn(T val) { - CALL("Int::sgn"); return (T(0) < val) - (val < T(0)); } @@ -197,8 +186,6 @@ class Int template static bool safeMultiply(INT arg1, INT arg2, INT& res) { - CALL("Int::safeMultiply"); - if (arg1 == 0 || arg1 == 1 || arg2 == 0 || arg2 == 1) { res=arg1*arg2; return true; @@ -231,7 +218,6 @@ class Int inline static bool safeDivide(int arg1, int arg2, int& res) { - CALL("Int::safeDivide"); if (arg2 == 0) return false; // check for 2 complement representation diff --git a/Lib/IntUnionFind.cpp b/Lib/IntUnionFind.cpp index f49c8bc85..a988e49e2 100644 --- a/Lib/IntUnionFind.cpp +++ b/Lib/IntUnionFind.cpp @@ -25,7 +25,6 @@ using namespace std; IntUnionFind::IntUnionFind(int cnt) : _cnt(cnt), _modified(true), _components(8) { - CALL("IntUnionFind::IntUnionFind"); ASS_G(cnt, 0); _parents=reinterpret_cast(ALLOC_KNOWN(_cnt*sizeof(int), "IntUnionFind")); @@ -44,8 +43,6 @@ IntUnionFind::~IntUnionFind() void IntUnionFind::reset() { - CALL("IntUnionFind::reset"); - for(int i=0;i<_cnt;i++) { _parents[i]=-1; } @@ -59,8 +56,6 @@ void IntUnionFind::reset() */ bool IntUnionFind::doUnion(int c1, int c2) { - CALL("IntUnionFind::doUnion"); - c1=root(c1); c2=root(c2); if(c1==c2) { @@ -83,8 +78,6 @@ bool IntUnionFind::doUnion(int c1, int c2) */ int IntUnionFind::root(int c) const { - CALL("IntUnionFind::root"); - static Stack path(8); ASS(path.isEmpty()); int prev=-1; @@ -105,8 +98,6 @@ int IntUnionFind::root(int c) const void IntUnionFind::evalComponents() { - CALL("IntUnionFind::evalComponents"); - if(!_modified) { //the components are already evaluated return; @@ -140,7 +131,6 @@ void IntUnionFind::evalComponents() */ int IntUnionFind::getComponentCount() { - CALL("IntUnionFind::getComponentCount"); ASS(!_modified); return _components.size(); diff --git a/Lib/IntUnionFind.hpp b/Lib/IntUnionFind.hpp index 852244d05..9c7adb780 100644 --- a/Lib/IntUnionFind.hpp +++ b/Lib/IntUnionFind.hpp @@ -69,7 +69,6 @@ class IntUnionFind { bool hasNext() { return _next!=-1; } int next() { - CALL("IntUnionFind::ElementIterator::next"); ASS_NEQ(_next,-1); int res=_next; @@ -106,7 +105,6 @@ class IntUnionFind { ComponentIterator(const IntUnionFind& obj) : _cit(obj._components), _data(obj._data) { - CALL("IntUnionFind::ComponentIterator::ComponentIterator"); ASS(!obj._modified); //the evalComponents function must have been called before } diff --git a/Lib/List.hpp b/Lib/List.hpp index 690155587..eb0acbdf6 100644 --- a/Lib/List.hpp +++ b/Lib/List.hpp @@ -160,8 +160,6 @@ class List /** Destroy the list */ static void destroy (List *l) { - CALL("List::destroy"); - if (isEmpty(l)) return; List* current = l; @@ -180,8 +178,6 @@ class List */ static void destroyWithDeletion(List *l) { - CALL("List::destroyWithDeletion"); - if (isEmpty(l)) return; List* current = l; @@ -269,7 +265,6 @@ class List /** pop the first element and return it */ static C pop(List* &lst) { - CALL("List::pop"); ASS_NEQ(lst,0); List* tail = lst->tail(); @@ -462,7 +457,6 @@ class List #if VDEBUG // Only works if called on a List of elements with toString functions vstring toString(){ - CALL("List::toString"); vstring h = _head->toString(); if(_tail){ return h+","+_tail->toString(); diff --git a/Lib/Map.hpp b/Lib/Map.hpp index 51a0088ca..bafe90149 100644 --- a/Lib/Map.hpp +++ b/Lib/Map.hpp @@ -18,7 +18,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "VString.hpp" @@ -58,7 +57,6 @@ class Map inline ~Entry() { - CALL("Entry::~Entry()") if (occupied()) { key().~Key(); value().~Val(); @@ -70,7 +68,6 @@ class Map explicit Entry(Entry const& other) : code(other.code) { - CALL("Entry(Entry const&)") if (other.occupied()) { init(Key(other.key()), Val(other.value()), other.code); } @@ -117,7 +114,6 @@ class Map /** initialize value underlying the wrapper type */ void init(Key key, Val val, unsigned code) { - CALL("Map::Entry::init(Key&&, Val&&, unsigned)") ASS_REP(this->code == 0, this->code) ASS(code != 0) ::new(&_key ) Key(std::move(key)); @@ -156,7 +152,6 @@ class Map _afterLast (other._afterLast), _maxEntries (other._maxEntries) { - CALL("Map(Map&&)"); other._capacity = 0; other._noOfEntries = 0; other._entries = nullptr; @@ -165,7 +160,6 @@ class Map } Map& operator=(Map&& other) { - CALL("Map& operator=(Map&&)"); _capacity = other._capacity; _noOfEntries = other._noOfEntries; _entries = other._entries; @@ -184,7 +178,6 @@ class Map /** Deallocate the map */ inline ~Map () { - CALL("Map::~Map"); clear(); } // Map::~Map @@ -208,7 +201,6 @@ class Map */ Option tryGet(Key const& key) const { - CALL("Map::find/2"); using Opt = Option; auto code = hashCode(key); @@ -231,8 +223,6 @@ class Map */ bool find(Key key, Val& found) const { - CALL("Map::find/2"); - auto out = tryGet(key); if (out.isSome()) { found = out.unwrap(); @@ -252,7 +242,6 @@ class Map */ Val* getPtr(const Key& key) { - CALL("Val* Map::getPtr(const Key&)"); auto code = hashCode(key); Entry* entry; for (entry = firstEntryForCode(code); entry->occupied(); entry = nextEntry(entry)) { @@ -272,7 +261,6 @@ class Map */ const Val* getPtr(const Key& key) const { - CALL("const Val* Map::getPtr(const Key&)"); auto code = hashCode(key); Entry* entry; for (entry = firstEntryForCode(code); entry->occupied(); entry = nextEntry(entry)) { @@ -294,8 +282,6 @@ class Map */ Val& get(Key key) const { - CALL("Map::get"); - auto code = hashCode(key); Entry* entry; for (entry = firstEntryForCode(code); !Hash::equals(entry->key(),key); entry = nextEntry(entry)) { @@ -336,8 +322,6 @@ class Map */ inline Val& insert(Key key,Val val) { - CALL("Map::insert"); - if (_noOfEntries >= _maxEntries) { // too many entries expand(); } @@ -359,8 +343,6 @@ class Map */ Val& insert(Key&& key, Val&& val,unsigned code) { - CALL("Map::insert/2"); - Entry* entry; for (entry = firstEntryForCode(code); entry->occupied(); entry = nextEntry(entry)) { if (entry->code == code && Hash::equals(entry->key(),key)) { @@ -385,8 +367,6 @@ class Map */ bool replaceOrInsert(Key key,Val val) { - CALL("Map::insertOrReplace"); - if (_noOfEntries >= _maxEntries) { // too many entries expand(); } @@ -413,8 +393,6 @@ class Map */ void replace(const Key key,const Val val) { - CALL("Map::replace"); - if (_noOfEntries >= _maxEntries) { // too many entries expand(); } @@ -440,7 +418,6 @@ class Map template Val& getOrInit(Key key, InitFn init) { - CALL("Map::getOrInit"); return updateOrInit(std::move(key), [](Val v) { return std::move(v); }, init); } @@ -456,8 +433,6 @@ class Map template Val& updateOrInit(Key key, UpdateFn update, InitFn init) { - CALL("Map::updateOrInit"); - if (_noOfEntries >= _maxEntries) { // too many entries expand(); } @@ -495,8 +470,6 @@ class Map */ bool getValuePtr(const Key& key, Val*& pval, const Val& initial) { - CALL("Map::getValuePtr"); - if (_noOfEntries >= _maxEntries) { // too many entries expand(); } @@ -535,8 +508,6 @@ class Map */ void deleteAll() { - CALL("Map::deleteAll"); - for (int i = _capacity-1;i >= 0;i--) { Entry& e = _entries[i]; if (e.occupied()) { @@ -559,8 +530,6 @@ class Map */ void destroyAll() { - CALL("Map::destroyAll"); - for (int i = _capacity-1;i >= 0;i--) { Entry& e = _entries[i]; if (e.occupied()) { @@ -583,8 +552,6 @@ class Map void expand() { - CALL("Map::expand"); - size_t oldCapacity = _capacity; _capacity = _capacity ? _capacity * 2 : 32; diff --git a/Lib/MaybeBool.hpp b/Lib/MaybeBool.hpp index ae571e5c4..900e7638e 100644 --- a/Lib/MaybeBool.hpp +++ b/Lib/MaybeBool.hpp @@ -18,7 +18,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" namespace Lib { @@ -44,7 +43,6 @@ class MaybeBool bool operator==(MaybeBool::Value o) const { return _value==o; } bool value() const { - CALL("MaybeBool::value"); ASS(known()); return _value==TRUE; } diff --git a/Lib/MemoryLeak.cpp b/Lib/MemoryLeak.cpp index 252cb3dc9..4185ca6c0 100644 --- a/Lib/MemoryLeak.cpp +++ b/Lib/MemoryLeak.cpp @@ -36,8 +36,6 @@ bool MemoryLeak::_cancelled = false; */ void MemoryLeak::release(Formula* f) { - CALL("MemoryLeak::release(Formula*)"); - if (_released.contains(f)) { return; } diff --git a/Lib/Metaiterators.hpp b/Lib/Metaiterators.hpp index 1aba9b19d..7b69b9642 100644 --- a/Lib/Metaiterators.hpp +++ b/Lib/Metaiterators.hpp @@ -71,7 +71,6 @@ class InfiniteArrayIterator template InfiniteArrayIterator getInfiniteArrayIterator(const El* ptr) { - CALL("getInfiniteArrayIterator"); return InfiniteArrayIterator(ptr); } @@ -120,7 +119,6 @@ class ArrayishObjectIterator template class ref_t = no_ref_t, class Arr> ArrayishObjectIterator getArrayishObjectIterator(Arr const& arr, size_t size) { - CALL("getArrayishObjectIterator"); return ArrayishObjectIterator(arr, size); } @@ -179,7 +177,6 @@ class InputIterator bool hasNext() const { return _remaining>0; } T next() { - CALL("InputIterator::next"); ASS_G(_remaining,0); _remaining--; T res; @@ -409,7 +406,6 @@ class FilteredIterator bool hasNext() { - CALL("FilteredIterator::hasNext") if(_next.isSome()) { return true; } @@ -424,7 +420,6 @@ class FilteredIterator }; OWN_ELEMENT_TYPE next() { - CALL("FilteredIterator::next") ALWAYS(hasNext()); ASS(_next.isSome()); auto out = std::move(_next).unwrap(); @@ -454,7 +449,6 @@ class FilterMapIter bool hasNext() { - CALL("FilterMapIter::hasNext") if(_next.isSome()) { return true; } @@ -469,7 +463,6 @@ class FilterMapIter OWN_ELEMENT_TYPE next() { - CALL("FilterMapIter::next") ALWAYS(hasNext()); ASS(_next.isSome()); auto out = std::move(_next).unwrap(); @@ -683,7 +676,7 @@ class MappingIterator DECL_ELEMENT_TYPE(ResultType); explicit MappingIterator(Inner inner, Functor func) : _func(std::move(func)), _inner(std::move(inner)) {} - inline bool hasNext() { CALL("MappingIterator::hasNext"); return _inner.hasNext(); }; + inline bool hasNext() { return _inner.hasNext(); }; inline ResultType next() { return _func(_inner.next()); }; /** @@ -836,7 +829,6 @@ class FlatteningIterator bool hasNext() { - CALL("FlatteningIterator::hasNext"); while (_current.isSome()) { if (_current.unwrap().hasNext()) { return true; @@ -852,7 +844,6 @@ class FlatteningIterator inline ELEMENT_TYPE(FlatteningIterator) next() { - CALL("FlatteningIterator::next"); ASS(_current.isSome()); ASS(_current.unwrap().hasNext()); return _current.unwrap().next(); @@ -1003,8 +994,6 @@ class UniquePersistentIterator static ItemList* getUniqueItemList(Inner& inn, size_t& sizeRef) { - CALL("UniquePersistentIterator::getUniqueItemList"); - ItemList* res=0; Recycled iset; @@ -1070,8 +1059,6 @@ VirtualIterator getUniquePersistentIteratorFromPtr(Inner* i template void makeUnique(Container& cont) { - CALL("makeUnique"); - VirtualIterator uniqueIt = pvi( getUniquePersistentIterator(ITERATOR_TYPE(Container)(cont)) ); cont.reset(); @@ -1084,8 +1071,6 @@ void makeUnique(Container& cont) template size_t countIteratorElements(It it) { - CALL("countIteratorElements"); - size_t res = 0; while(it.hasNext()) { it.next(); @@ -1365,8 +1350,6 @@ auto timeTraceIter(const char* name, Iter iter) template bool iteratorsEqual(It1 it1, It2 it2) { - CALL("iteratorsEqual"); - while(it1.hasNext()) { if(!it2.hasNext()) { return false; @@ -1388,8 +1371,6 @@ static bool lessThan(T a, T b) { return a bool isSorted(It it) { - CALL("isSorted/1"); - if(!it.hasNext()) { return true; } ELEMENT_TYPE(It) prev = it.next(); @@ -1413,8 +1394,6 @@ bool isSorted(It it) template bool isSorted(It it, Pred lessThan) { - CALL("isSorted/2"); - if(!it.hasNext()) { return true; } ELEMENT_TYPE(It) prev = it.next(); @@ -1435,8 +1414,6 @@ bool isSorted(It it, Pred lessThan) template bool forAll(It it, Pred pred) { - CALL("forAll"); - while(it.hasNext()) { if(!pred(it.next())) { return false; @@ -1452,8 +1429,6 @@ bool forAll(It it, Pred pred) template ELEMENT_TYPE(It) getFirstTrue(It it, Pred pred) { - CALL("getFirstTrue"); - while(it.hasNext()) { ELEMENT_TYPE(It) el = it.next(); if(pred(el)) { @@ -1471,7 +1446,6 @@ ELEMENT_TYPE(It) getFirstTrue(It it, Pred pred) template Res fold(It it, Fun fn, Res init) { - CALL("fold/3"); Res res = init; while(it.hasNext()) { res = fn(it.next(), res); @@ -1488,8 +1462,6 @@ Res fold(It it, Fun fn, Res init) template ELEMENT_TYPE(It) fold(It it, Fun fn) { - CALL("fold/2"); - ALWAYS(it.hasNext()); ELEMENT_TYPE(It) init = it.next(); return fold(it,fn,init); @@ -1545,8 +1517,6 @@ std::ostream& operator<< (ostream& out, const StmJoinAuxStruct& info ) template bool splitIterator(It it, Pred edge, VirtualIterator& res1, VirtualIterator& res2) { - CALL("splitIterator"); - typedef ELEMENT_TYPE(It) T; bool success = false; @@ -1612,7 +1582,6 @@ struct CompositionFn { template CompositionFn getCompositionFn(OuterFn outer, InnerFn inner) { - CALL("getCompositionFn"); return CompositionFn(outer,inner); } @@ -1642,13 +1611,11 @@ class IterTraits Elem next() { - CALL("IterTraits::next") return _iter.next(); } bool hasNext() { - CALL("IterTraits::hasNext") return _iter.hasNext(); } @@ -1663,7 +1630,6 @@ class IterTraits template bool any(P f) { - CALL("IterTraits::any") while (hasNext()) { if (f(next())) return true; } @@ -1673,7 +1639,6 @@ class IterTraits template bool all(P f) { - CALL("IterTraits::all") while (hasNext()) { if (!f(next())) return false; } @@ -1683,7 +1648,6 @@ class IterTraits template void forEach(F f) { - CALL("IterTraits::forEach") while (hasNext()) { f(next()); } @@ -1692,7 +1656,6 @@ class IterTraits template Option find(P p) { - CALL("IterTraits::find") while (hasNext()) { Elem x = next(); if (p(x)) { @@ -1705,7 +1668,6 @@ class IterTraits template Option findPosition(P p) { - CALL("IterTraits::findPosition") unsigned i = 0; while (hasNext()) { Elem x = next(); @@ -1768,7 +1730,6 @@ class IterTraits template Option minBy(IsLess isLess) { - CALL("IterTraits::min") if (hasNext()) { Elem min = next(); while (hasNext()) { @@ -1817,7 +1778,6 @@ class IterTraits template Container collect() { - CALL("IterTraits::collect/1") return Container::fromIterator(*this); } @@ -1825,7 +1785,6 @@ class IterTraits template class Container> Container collect() { - CALL("IterTraits::collect/2") return Container::fromIterator(*this); } diff --git a/Lib/MultiCounter.cpp b/Lib/MultiCounter.cpp index bb5fff0cd..9a431ed35 100644 --- a/Lib/MultiCounter.cpp +++ b/Lib/MultiCounter.cpp @@ -15,7 +15,6 @@ * @since 06/01/2004, Manchester */ -#include "Debug/Tracer.hpp" #include "MultiCounter.hpp" #include "Int.hpp" @@ -31,8 +30,6 @@ using namespace Lib; */ void MultiCounter::expandToFit (int v) { - CALL("MultiCounter::expandToFit"); - // calculate the new capacity int newTop = max(_top*2,v+1); diff --git a/Lib/NameArray.cpp b/Lib/NameArray.cpp index 0661c097b..f583df172 100644 --- a/Lib/NameArray.cpp +++ b/Lib/NameArray.cpp @@ -19,7 +19,6 @@ #include "Exception.hpp" #include "NameArray.hpp" -#include "Debug/Tracer.hpp" namespace Lib { @@ -45,8 +44,6 @@ NameArray::NameArray (const char* array[],int len) */ int NameArray::find (const char* value) const { - CALL("NameArray::find"); - int res=tryToFind(value); if(res==-1) { throw ValueNotFoundException(); @@ -60,8 +57,6 @@ int NameArray::find (const char* value) const */ int NameArray::tryToFind(const char* value) const { - CALL("NameArray::tryToFind"); - int from = 0; int to = length; while (from < to) { diff --git a/Lib/Numbering.hpp b/Lib/Numbering.hpp index 48f28fcaa..8a0580eb6 100644 --- a/Lib/Numbering.hpp +++ b/Lib/Numbering.hpp @@ -27,7 +27,6 @@ class Numbering Numbering() : _nextNum(Start) {} unsigned get(T obj) { - CALL("Numbering::get"); unsigned* pres; if(_map.getValuePtr(obj, pres, _nextNum)) { ALWAYS(_rev.insert(_nextNum, obj)); @@ -37,7 +36,6 @@ class Numbering } void assign(T obj, unsigned num) { - CALL("Numbering::assign"); if(_map.insert(obj, num)) { ALWAYS(_rev.insert(num, obj)); if(num>=_nextNum) { @@ -55,12 +53,10 @@ class Numbering */ unsigned getSpareNum() { - CALL("Numbering::getSpareNum"); return _nextNum++; } T obj(unsigned num) const { - CALL("Numbering::obj"); return _rev.get(num); } bool findObj(unsigned num, T& res) const @@ -75,7 +71,6 @@ class Numbering * to the result of this function */ unsigned getNumberUpperBound() const { - CALL("Numbering::getNumberUpperBound"); return _nextNum==0 ? 0 : (_nextNum-1); } void reset(){ diff --git a/Lib/Option.hpp b/Lib/Option.hpp index 871522d0f..d0fe420c0 100644 --- a/Lib/Option.hpp +++ b/Lib/Option.hpp @@ -18,7 +18,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include @@ -69,7 +68,6 @@ class OptionBase ~OptionBase() { - CALL("~OptionBase") if (isSome()) { unwrap().~A(); } @@ -78,7 +76,6 @@ class OptionBase : _isSome(true) , _elem() { - CALL("Option(A)") _elem.init(std::move(content)); } @@ -93,7 +90,6 @@ class OptionBase \ OptionBase(OptionBase REF a) : _isSome(a._isSome) \ { \ - CALL("OptionBase(OptionBase " #REF ")"); \ if (isSome()) { \ _elem.init(MV(a).unwrap()); \ } \ @@ -101,8 +97,6 @@ class OptionBase \ OptionBase& operator=(OptionBase REF other) \ { \ - CALL("OptionBase& operator=(OptionBase "#REF")"); \ - \ if (_isSome) { \ if (other._isSome) { \ unwrap() = MV(other).unwrap(); \ diff --git a/Lib/Perfect.hpp b/Lib/Perfect.hpp index 2f9c4ab9a..b3b0827d4 100644 --- a/Lib/Perfect.hpp +++ b/Lib/Perfect.hpp @@ -13,7 +13,6 @@ #include #include "Lib/Map.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Coproduct.hpp" namespace Lib { diff --git a/Lib/Random.hpp b/Lib/Random.hpp index 04196b28a..8c00e9403 100644 --- a/Lib/Random.hpp +++ b/Lib/Random.hpp @@ -20,7 +20,6 @@ #ifndef __RANDOM__ # define __RANDOM__ -#include "Debug/Tracer.hpp" #include #include @@ -51,12 +50,10 @@ class Random public: static inline int getInteger(int modulus) { - CALL("Random::getInt"); return std::uniform_int_distribution(0,modulus-1)(_eng); } static double getDouble(double min, double max) { - CALL("Random::getDouble"); return std::uniform_real_distribution(min,max)(_eng); } @@ -72,8 +69,6 @@ class Random /** Set random seed to s */ inline static void setSeed(unsigned s) { - CALL("Random::setSeed"); - _seed = s; _eng.seed(_seed); } @@ -84,8 +79,6 @@ class Random /** Try hard to set the seed to something non-deterministic random. */ inline static void resetSeed () { - CALL("Random::resetSeed"); - setSeed(std::random_device()()); } }; // class Random diff --git a/Lib/RatioKeeper.hpp b/Lib/RatioKeeper.hpp index 897c04e68..ac4da9357 100644 --- a/Lib/RatioKeeper.hpp +++ b/Lib/RatioKeeper.hpp @@ -17,7 +17,6 @@ #include "Forwards.hpp" -#include "Debug/Tracer.hpp" namespace Lib { @@ -37,7 +36,6 @@ class RatioKeeper { void doFirst(int cost=1) { - CALL("RatioKeeper::doFirst"); ASS(shouldDoFirst()); _balance -= cost*_secondRatio; _lastWasFirst = true; @@ -45,7 +43,6 @@ class RatioKeeper { void doSecond(int cost=1) { - CALL("RatioKeeper::doSecond"); ASS(shouldDoSecond()); _balance += cost*_firstRatio; _lastWasFirst = false; diff --git a/Lib/ScopedPtr.hpp b/Lib/ScopedPtr.hpp index c7359a111..3eeb0c078 100644 --- a/Lib/ScopedPtr.hpp +++ b/Lib/ScopedPtr.hpp @@ -18,7 +18,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" namespace Lib { @@ -44,15 +43,12 @@ class ScopedPtr { inline ~ScopedPtr() { - CALL("Lib::ScopedPtr::~ScopedPtr"); if(_obj) { checked_delete(_obj); } } void operator=(T* obj) { - CALL("SmartPtr::operator="); - if(_obj) { checked_delete(_obj); } @@ -65,7 +61,6 @@ class ScopedPtr { inline T* operator->() const { - CALL("ScopedPtr::operator->"); ASS(_obj); return _obj; @@ -73,7 +68,6 @@ class ScopedPtr { inline T& operator*() const { - CALL("ScopedPtr::operator*"); ASS(_obj); return *_obj; diff --git a/Lib/Set.hpp b/Lib/Set.hpp index 6e57813d0..030d1173f 100644 --- a/Lib/Set.hpp +++ b/Lib/Set.hpp @@ -93,7 +93,6 @@ class Set _size(0), _entries(0) { - CALL("Set::Set"); expand(); } // Set::Set @@ -107,8 +106,6 @@ class Set /** Deallocate the set */ inline ~Set () { - CALL("~Set"); - if (_entries) { array_delete(_entries,_capacity); DEALLOC_KNOWN(_entries,_capacity*sizeof(Cell),"Set::Cell"); @@ -126,8 +123,6 @@ class Set template bool find(Key key, Val& result) const { - CALL("Set::find"); - unsigned code = Hash::hash(key); if (code < 2) { code = 2; @@ -153,8 +148,6 @@ class Set */ bool contains (Val val) const { - CALL("Set::contains"); - unsigned code = Hash::hash(val); if (code < 2) { code = 2; @@ -182,8 +175,6 @@ class Set */ inline Val insert(const Val val) { - CALL("Set::insert"); - if (_nonemptyCells >= _maxEntries) { // too many entries expand(); } @@ -205,8 +196,6 @@ class Set */ Val insert(const Val val,unsigned code) { - CALL("Set::insert/2"); - Cell* found = 0; Cell* cell = firstCellForCode(code); while (! cell->empty()) { @@ -256,8 +245,6 @@ class Set */ bool remove(const Val val) { - CALL("Set::remove"); - unsigned code = Hash::hash(val); if (code < 2) { code = 2; @@ -288,7 +275,6 @@ class Set */ void reset() { - CALL("Set::reset"); Cell* ptr = _entries; while(ptr!=_afterLast) { ptr->code = 0; @@ -304,8 +290,6 @@ class Set */ void deleteAll() { - CALL("Set::deleteAll"); - for (int i = _capacity-1;i >= 0;i--) { Cell& e = _entries[i]; if (e.occupied()) { @@ -339,8 +323,6 @@ class Set */ void expand() { - CALL("Set::expand"); - size_t newCapacity = _capacity ? _capacity * 2 : 31; Cell* oldEntries = _entries; diff --git a/Lib/SharedSet.hpp b/Lib/SharedSet.hpp index 7fe702e35..2c2995bb9 100644 --- a/Lib/SharedSet.hpp +++ b/Lib/SharedSet.hpp @@ -18,7 +18,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "Metaiterators.hpp" @@ -50,7 +49,6 @@ class SharedSet { inline T operator[] (size_t n) const { - CALL("SharedSet::operator[]"); ASS_L(n,size()); return _items[n]; @@ -61,7 +59,6 @@ class SharedSet { */ inline T sval() const { - CALL("SharedSet::sval"); ASS_EQ(size(),1); return (*this)[0]; @@ -72,7 +69,6 @@ class SharedSet { */ inline T maxval() const { - CALL("SharedSet::maxval"); ASS(!isEmpty()); return (*this)[size()-1]; @@ -80,8 +76,6 @@ class SharedSet { bool member(T val) const { - CALL("SharedSet::member"); - size_t l=0; size_t r=size(); while(lisEmpty()) { @@ -168,7 +161,6 @@ class SharedSet { const SharedSet* getIntersection(const SharedSet* s) const { - CALL("SharedSet::getIntersection"); ASS(s); if(s==this) { @@ -209,7 +201,6 @@ class SharedSet { */ const SharedSet* subtract(const SharedSet* s) const { - CALL("SharedSet::subtract"); ASS(s); if(s==this) { @@ -251,7 +242,6 @@ class SharedSet { bool hasIntersection(const SharedSet* s) const { - CALL("SharedSet::hasIntersection"); ASS(s); const T* p1=_items; @@ -277,7 +267,6 @@ class SharedSet { bool isSubsetOf(const SharedSet* s) const { - CALL("SharedSet::isSubsetOf"); ASS(s); if(s->size()(obj); // calculate the same thing as in operator new @@ -445,8 +420,6 @@ class SharedSet { static bool equals(const T* arr1, const T* arr2, size_t len) { - CALL("SharedSet::equals(T*,T*,size_t)"); - const T* arr1e=arr1+len; while(arr1!=arr1e) { if(*arr1!=*arr2) { @@ -459,7 +432,6 @@ class SharedSet { } static unsigned hash(const T* arr, size_t len) { - CALL("SharedSet::hash(T*,size_t)"); static_assert(std::is_arithmetic::value, "T must be safely hashable"); return DefaultHash::hashBytes( reinterpret_cast(arr), @@ -469,8 +441,6 @@ class SharedSet { static const SharedSet* create(const ItemStack& is) { - CALL("SharedSet::create"); - size_t sz=is.size(); if(!sz) { diff --git a/Lib/SkipList.hpp b/Lib/SkipList.hpp index a465f97bf..3aa942352 100644 --- a/Lib/SkipList.hpp +++ b/Lib/SkipList.hpp @@ -19,7 +19,6 @@ # define __SkipList__ #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "Backtrackable.hpp" @@ -62,7 +61,6 @@ class SkipList inline void insert(Value val) { - CALL("SkipList::insert"); Value* pval = insertPosition(val); *pval = val; } // SkipList::insert @@ -71,8 +69,6 @@ class SkipList inline void insertFromIterator(Iterator it) { - CALL("SkipList::insertFromIterator"); - while(it.hasNext()) { insert(it.next()); } @@ -85,7 +81,6 @@ class SkipList inline bool ensurePresent(Value val) { - CALL("SkipList::ensurePresent"); Value* pval; if(!getPosition(val, pval, true)) { *pval = val; @@ -107,8 +102,6 @@ class SkipList template bool getPosition(Key key, Value*& pvalue, bool canCreate) { - CALL("SkipList::getPosition"); - if(_top==0) { if(canCreate) { pvalue = insertPosition(key); @@ -174,8 +167,6 @@ class SkipList template Value* insertPosition(Key key) { - CALL("SkipList::insertPosition"); - // select a random height between 0 and top unsigned nodeHeight = 0; while (Random::getBit()) { @@ -252,8 +243,6 @@ class SkipList template bool findLeastGreater(Key key, Value& value) { - CALL("SkipList::findLeastGreater"); - if(_top==0) { return false; } @@ -362,7 +351,6 @@ class SkipList */ Value pop() { - CALL("SkipList::pop"); ASS(isNonEmpty()); // find the height of the first @@ -406,7 +394,6 @@ class SkipList template void remove(Key key) { - CALL("SkipList::remove"); ASS(_top > 0); Node* found = 0; // found node @@ -518,7 +505,6 @@ class SkipList : _left(allocate(SKIP_LIST_MAX_HEIGHT)), _top(0) { - CALL("SkipList::SkipList"); for (int h = SKIP_LIST_MAX_HEIGHT-1;h >= 0;h--) { _left->nodes[h] = 0; } @@ -529,8 +515,6 @@ class SkipList */ ~SkipList() { - CALL("SkipList::~SkipList"); - makeEmpty(); deallocate(_left,SKIP_LIST_MAX_HEIGHT); } @@ -544,8 +528,6 @@ class SkipList inline static Node* allocate(unsigned h) { - CALL("SkipList::allocate"); - void* memory = ALLOC_KNOWN(sizeof(Node)+h*sizeof(Node*),"SkipList::Node"); return reinterpret_cast(memory); @@ -555,7 +537,6 @@ class SkipList inline static void deallocate(Node* node,unsigned h) { - CALL("SkipList::deallocate"); DEALLOC_KNOWN(node,sizeof(Node)+h*sizeof(Node*),"SkipList::Node"); } diff --git a/Lib/SmartPtr.hpp b/Lib/SmartPtr.hpp index 429d6a715..ad461e59f 100644 --- a/Lib/SmartPtr.hpp +++ b/Lib/SmartPtr.hpp @@ -20,7 +20,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Allocator.hpp" @@ -73,8 +72,6 @@ class SmartPtr { } SmartPtr& operator=(const SmartPtr& ptr) { - CALL("SmartPtr::operator="); - T* oldObj=_obj; RefCounter* oldCnt=_refCnt; _obj=ptr._obj; diff --git a/Lib/Sort.hpp b/Lib/Sort.hpp index 95fce1a8d..0feff9153 100644 --- a/Lib/Sort.hpp +++ b/Lib/Sort.hpp @@ -20,7 +20,6 @@ # define __Sort__ #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "DArray.hpp" @@ -32,8 +31,6 @@ struct DefaultComparator template static Comparison compare(T a, T b) { - CALL("DefaultComparator::compare"); - if(a==b) { return EQUAL; } @@ -50,7 +47,6 @@ struct DefaultComparator template void sort(C* first, C* afterLast) { - CALL("sort"); //modified sorting code, that was originally in Resolution::Tautology::sort C* arr=first; @@ -176,16 +172,12 @@ class Sort _length(0), _comparator(comparator) { - CALL("Sort::Sort"); - void* mem = ALLOC_KNOWN(length*sizeof(ToCompare),"Sort<>"); _elems = array_new(mem, length); } inline ~Sort () { - CALL("Sort::~Sort"); - array_delete(_elems,_size); DEALLOC_KNOWN(_elems,_size*sizeof(ToCompare),"Sort<>"); } @@ -221,7 +213,6 @@ class Sort */ inline void sort () { - CALL("Sort::sort/0"); sort (0,_length-1); } @@ -257,7 +248,6 @@ class Sort */ void sort(int p,int r) { - CALL("Sort::sort/2"); ASS(r < _length); if (p >= r) { @@ -309,8 +299,6 @@ class Sort */ bool member (const ToCompare elem, int fst, int lst) const { - CALL("Sort::member"); - for (;;) { if (fst > lst) { return false; diff --git a/Lib/Stack.hpp b/Lib/Stack.hpp index a7d0ede51..0f1903ac6 100644 --- a/Lib/Stack.hpp +++ b/Lib/Stack.hpp @@ -22,7 +22,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "Backtrackable.hpp" @@ -65,8 +64,6 @@ class Stack explicit Stack (size_t initialCapacity=0) : _capacity(initialCapacity) { - CALL("Stack::Stack"); - if(_capacity) { void* mem = ALLOC_KNOWN(_capacity*sizeof(C),className()); _stack = static_cast(mem); @@ -81,7 +78,6 @@ class Stack inline void reserve(size_t capacity) { - CALL("Stack::reserve(size_t)"); if (_capacity >= capacity) { return; } @@ -108,8 +104,6 @@ class Stack Stack(const Stack& s) : _capacity(s._capacity) { - CALL("Stack::Stack(const Stack&)"); - if(_capacity) { void* mem = ALLOC_KNOWN(_capacity*sizeof(C),className()); _stack = static_cast(mem); @@ -125,8 +119,6 @@ class Stack Stack(Stack&& s) noexcept { - CALL("Stack::Stack(Stack&& s)"); - _capacity = 0; _stack = _cursor = _end = nullptr; @@ -138,8 +130,6 @@ class Stack */ inline ~Stack() { - CALL("Stack::~Stack"); - //The while cycle is completely eliminated by compiler //in "-O6 -DVDEBUG=0" mode for types without destructor, //so this destructor is constant time. @@ -157,8 +147,6 @@ class Stack Stack& operator=(const Stack& s) { - CALL("Stack::operator="); - if(&s == this) { return *this; } @@ -169,8 +157,6 @@ class Stack Stack& operator=(Stack&& s) noexcept { - CALL("Stack::operator=&&"); - std::swap(*this,s); return *this; } @@ -181,8 +167,6 @@ class Stack */ template void loadFromIterator(It it) { - CALL("Stack::loadFromIterator"); - // TODO check iterator.size() or iterator.sizeHint() while(it.hasNext()) { push(it.next()); @@ -194,8 +178,6 @@ class Stack */ template void moveFromIterator(It it) { - CALL("Stack::loadFromIterator"); - // TODO check iterator.size() or iterator.sizeHint() while(it.hasNext()) { push(std::move(it.next())); @@ -208,7 +190,6 @@ class Stack */ template static Stack fromIterator(It it) { - CALL("Stack::fromIterator"); Stack out; out.loadFromIterator(it); return out; @@ -245,8 +226,6 @@ class Stack bool operator==(const Stack& o) const { - CALL("Stack::operator=="); - if(size()!=o.size()) { return false; } @@ -295,7 +274,6 @@ class Stack inline void setTop(C elem) { - CALL("Stack::setTop"); ASS(_cursor > _stack); ASS(_cursor <= _end); @@ -329,8 +307,6 @@ class Stack inline void push(const C& elem) { - CALL("Stack::push"); - if (_cursor == _end) { expand(); } @@ -346,8 +322,6 @@ class Stack inline void push(C&& elem) { - CALL("Stack::push"); - if (_cursor == _end) { expand(); } @@ -363,8 +337,6 @@ class Stack inline C pop() { - CALL("Stack::pop"); - ASS(_cursor > _stack); _cursor--; @@ -378,7 +350,6 @@ class Stack inline void pop(unsigned cnt) { - CALL("Stack::pop(unsigned)"); while (cnt-- != 0) pop(); } // Stack::pop(unsigned) @@ -452,8 +423,6 @@ class Stack bool find(const C& el) const { - CALL("Stack::find"); - Iterator it(const_cast(*this)); while(it.hasNext()) { if(it.next()==el) { @@ -645,7 +614,6 @@ class Stack inline bool hasNext() const { - CALL("Stack::BottomFirstIterator::hasNext()") ASS_LE(_pointer, _afterLast); return _pointer != _afterLast; } @@ -654,7 +622,6 @@ class Stack inline const C& next() { - CALL("Stack::BottomFirstIterator::next()") ASS_L(_pointer, _afterLast); return *(_pointer++); } @@ -794,8 +761,6 @@ class Stack */ void expand () { - CALL("Stack::expand"); - ASS(_cursor == _end); size_t newCapacity = _capacity ? (2 * _capacity) : 8; @@ -853,8 +818,6 @@ class Stack Stack(std::initializer_list cont) : Stack(cont.size()) { - CALL("Stack::Stack(initializer_list)"); - for (auto const& x : cont) { push(x); } @@ -870,8 +833,6 @@ namespace std template void swap(Lib::Stack& s1, Lib::Stack& s2) { - CALL("std::swap(Stack&,Stack&)"); - swap(s1._capacity, s2._capacity); swap(s1._cursor, s2._cursor); swap(s1._end, s2._end); diff --git a/Lib/StringUtils.cpp b/Lib/StringUtils.cpp index 2254f631c..89fee7900 100644 --- a/Lib/StringUtils.cpp +++ b/Lib/StringUtils.cpp @@ -25,8 +25,6 @@ using namespace std; vstring StringUtils::replaceChar(vstring str, char src, char target) { - CALL("StringUtils::replaceChar"); - size_t len=str.size(); static DArray buf; buf.ensure(len); @@ -54,8 +52,6 @@ vstring StringUtils::replaceChar(vstring str, char src, char target) */ vstring StringUtils::sanitizeSuffix(vstring str) { - CALL("StringUtils::sanitizeSuffix"); - size_t len=str.size(); static DArray buf; buf.ensure(len); @@ -89,8 +85,6 @@ vstring StringUtils::sanitizeSuffix(vstring str) bool StringUtils::isPositiveInteger(vstring str) { - CALL("StringUtils::isPositiveInteger"); - size_t sz = str.size(); if(str[0]=='0') { @@ -106,8 +100,6 @@ bool StringUtils::isPositiveInteger(vstring str) bool StringUtils::isPositiveDecimal(vstring str) { - CALL("StringUtils::isPositiveDecimal"); - size_t sz = str.size(); size_t i = 0; @@ -131,8 +123,6 @@ bool StringUtils::isPositiveDecimal(vstring str) void StringUtils::splitStr(const char* str, char delimiter, Stack& strings) { - CALL("StringUtils::splitStr"); - static Stack currPart; currPart.reset(); @@ -154,8 +144,6 @@ void StringUtils::splitStr(const char* str, char delimiter, Stack& stri bool StringUtils::readEquality(const char* str, char eqChar, vstring& lhs, vstring& rhs) { - CALL("StringUtils::readEquality"); - static Stack parts; parts.reset(); splitStr(str, eqChar, parts); @@ -172,8 +160,6 @@ bool StringUtils::readEquality(const char* str, char eqChar, vstring& lhs, vstri */ bool StringUtils::readEqualities(const char* str, char delimiter, char eqChar, DHMap& pairs) { - CALL("StringUtils::readEqualities"); - static Stack parts; parts.reset(); splitStr(str, delimiter, parts); diff --git a/Lib/Sys/Multiprocessing.cpp b/Lib/Sys/Multiprocessing.cpp index 68c4f8d9e..a7e0070b8 100644 --- a/Lib/Sys/Multiprocessing.cpp +++ b/Lib/Sys/Multiprocessing.cpp @@ -54,7 +54,6 @@ Multiprocessing::~Multiprocessing() void Multiprocessing::registerForkHandlers(VoidFunc before, VoidFunc afterParent, VoidFunc afterChild) { - CALL("Multiprocessing::registerForkHandlers"); if(before) { VoidFuncList::push(before, _preFork); } @@ -68,8 +67,6 @@ void Multiprocessing::registerForkHandlers(VoidFunc before, VoidFunc afterParent void Multiprocessing::executeFuncList(VoidFuncList* lst) { - CALL("Multiprocessing::executeFuncList"); - VoidFuncList::Iterator fit(lst); while(fit.hasNext()) { VoidFunc func=fit.next(); @@ -80,7 +77,6 @@ void Multiprocessing::executeFuncList(VoidFuncList* lst) pid_t Multiprocessing::fork() { - CALL("Multiprocessing::fork"); ASS(!env.haveOutput()); executeFuncList(_preFork); @@ -105,7 +101,6 @@ pid_t Multiprocessing::fork() */ pid_t Multiprocessing::waitForChildTermination(int& resValue) { - CALL("Multiprocessing::waitForChildTermination"); TIME_TRACE("waiting for child") int status; @@ -131,8 +126,6 @@ pid_t Multiprocessing::waitForChildTermination(int& resValue) void Multiprocessing::kill(pid_t child, int signal) { - CALL("Multiprocessing::kill"); - int res = ::kill(child, signal); if(res!=0) { ASS_EQ(res,-1); @@ -142,14 +135,11 @@ void Multiprocessing::kill(pid_t child, int signal) void Multiprocessing::killNoCheck(pid_t child, int signal) { - CALL("Multiprocessing::killNoCheck"); ::kill(child, signal); } pid_t Multiprocessing::poll_children(bool &exited, bool &signalled, int &code) { - CALL("Multiprocessing::poll_child"); - int status; pid_t pid = waitpid(-1 /*wait for any child*/, &status, WUNTRACED); diff --git a/Lib/Sys/Semaphore.cpp b/Lib/Sys/Semaphore.cpp index 2ed23b32a..b0623fd28 100644 --- a/Lib/Sys/Semaphore.cpp +++ b/Lib/Sys/Semaphore.cpp @@ -53,7 +53,6 @@ Semaphore::SemaphoreList* Semaphore::s_instances = 0; Semaphore::Semaphore(int num) :semCnt(num) { - CALL("Semaphore::Semaphore(int)"); ASS_G(num,0); ensureEventHandlersInstalled(); @@ -93,15 +92,11 @@ Semaphore::Semaphore(int num) Semaphore::~Semaphore() { - CALL("Semaphore::~Semaphore"); - deregisterInstance(); } Semaphore::Semaphore(const Semaphore& s) { - CALL("Semaphore::Semaphore(const Semaphore&)"); - semid=s.semid; semCnt=s.semCnt; registerInstance(); @@ -109,8 +104,6 @@ Semaphore::Semaphore(const Semaphore& s) const Semaphore& Semaphore::operator=(const Semaphore& s) { - CALL("Semaphore::operator="); - deregisterInstance(); semid=s.semid; semCnt=s.semCnt; @@ -124,7 +117,6 @@ const Semaphore& Semaphore::operator=(const Semaphore& s) */ void Semaphore::doInc(int num) { - CALL("Semaphore::doInc"); ASS(hasSemaphore()); ASS_L(num, semCnt+2); @@ -146,7 +138,6 @@ void Semaphore::doInc(int num) * */ void Semaphore::doIncPersistent(int num) { - CALL("Semaphore::doIncPersistent"); ASS(hasSemaphore()); ASS_L(num, semCnt+2); @@ -168,7 +159,6 @@ void Semaphore::doIncPersistent(int num) */ void Semaphore::doDec(int num) { - CALL("Semaphore::doDec"); ASS(hasSemaphore()); ASS_L(num, semCnt+2); @@ -195,7 +185,6 @@ void Semaphore::doDec(int num) */ void Semaphore::doSet(int num, int val) { - CALL("Semaphore::doSet"); ASS(hasSemaphore()); ASS_L(num, semCnt+2); ASS_GE(val,0); //semaphores cannot be negative @@ -216,7 +205,6 @@ void Semaphore::doSet(int num, int val) */ int Semaphore::doGet(int num) { - CALL("Semaphore::doGet"); ASS(hasSemaphore()); ASS_L(num, semCnt+2); @@ -236,7 +224,6 @@ int Semaphore::doGet(int num) */ void Semaphore::inc(int num) { - CALL("Semaphore::inc"); ASS(hasSemaphore()); ASS_L(num, semCnt); @@ -248,7 +235,6 @@ void Semaphore::inc(int num) * */ void Semaphore::incp(int num) { - CALL("Semaphore::incp"); ASS(hasSemaphore()); ASS_L(num, semCnt); @@ -262,7 +248,6 @@ void Semaphore::incp(int num) */ void Semaphore::dec(int num) { - CALL("Semaphore::dec"); ASS(hasSemaphore()); ASS_L(num, semCnt); @@ -274,7 +259,6 @@ void Semaphore::dec(int num) */ int Semaphore::get(int num) { - CALL("Semaphore::get"); ASS(hasSemaphore()); ASS_L(num, semCnt); @@ -286,7 +270,6 @@ int Semaphore::get(int num) */ void Semaphore::set(int num, int val) { - CALL("Semaphore::set"); ASS(hasSemaphore()); ASS_L(num, semCnt); ASS_GE(val, 0); @@ -300,7 +283,6 @@ void Semaphore::set(int num, int val) */ bool Semaphore::isLastInstance() { - CALL("Semaphore::isLastInstance"); ASS(hasSemaphore()); return doGet(semCnt)==1; @@ -315,8 +297,6 @@ bool Semaphore::isLastInstance() */ void Semaphore::registerInstance(bool addToInstanceList) { - CALL("Semaphore::registerInstance"); - if(!hasSemaphore()) { return; } @@ -334,8 +314,6 @@ void Semaphore::registerInstance(bool addToInstanceList) */ void Semaphore::deregisterInstance() { - CALL("Semaphore::deregisterInstance"); - if(!hasSemaphore()) { return; } @@ -350,7 +328,6 @@ void Semaphore::deregisterInstance() */ void Semaphore::acquireInstance() { - CALL("Semaphore::acquireInstance"); ASS(hasSemaphore()); doInc(semCnt); @@ -362,7 +339,6 @@ void Semaphore::acquireInstance() */ void Semaphore::releaseInstance() { - CALL("Semaphore::releaseInstance"); ASS(hasSemaphore()); //Here we may wait until other deregisterInstance() calls finish. @@ -398,8 +374,6 @@ void Semaphore::releaseInstance() */ void Semaphore::releaseAllSemaphores() { - CALL("Semaphore::releaseAllSemaphores"); - SemaphoreList* instIter=s_instances; while(instIter) { Semaphore* s=instIter->head(); @@ -418,8 +392,6 @@ void Semaphore::releaseAllSemaphores() */ void Semaphore::postForkInChild() { - CALL("Semaphore::postForkInChild"); - SemaphoreList::Iterator sit(s_instances); while(sit.hasNext()) { Semaphore* s=sit.next(); @@ -433,8 +405,6 @@ void Semaphore::postForkInChild() */ void Semaphore::ensureEventHandlersInstalled() { - CALL("Semaphore::ensureForkHandlerInstalled"); - static bool installed=false; if(installed) { return; diff --git a/Lib/Sys/SyncPipe.cpp b/Lib/Sys/SyncPipe.cpp index 15b082403..fe2a33993 100644 --- a/Lib/Sys/SyncPipe.cpp +++ b/Lib/Sys/SyncPipe.cpp @@ -69,8 +69,6 @@ SyncPipe::SyncPipe() SyncPipe::~SyncPipe() { - CALL("SyncPipe::~SyncPipe"); - releasePrivileges(); ASS(PipeList::member(this, s_instances)); s_instances = PipeList::remove(this, s_instances); @@ -88,7 +86,6 @@ SyncPipe::~SyncPipe() */ void SyncPipe::acquireRead() { - CALL("SyncPipe::acquireRead"); ASS(canRead()); ASS(!isReading()); ASS(!isWriting()); //it does not make sense if one process would both reads and writes into a pipe @@ -111,7 +108,6 @@ void SyncPipe::acquireRead() */ void SyncPipe::releaseRead() { - CALL("SyncPipe::releaseRead"); ASS(isReading()); _isReading=false; @@ -133,7 +129,6 @@ void SyncPipe::releaseRead() */ void SyncPipe::neverRead() { - CALL("SyncPipe::neverRead"); ASS(canRead()); //@b neverRead() can only be called once ASS(!isReading()); @@ -156,7 +151,6 @@ void SyncPipe::neverRead() */ void SyncPipe::acquireWrite() { - CALL("SyncPipe::acquireWrite"); ASS(canWrite()); ASS(!isWriting()); ASS(!isReading()); //it does not make sense if one process would both reads and writes into a pipe @@ -170,7 +164,6 @@ void SyncPipe::acquireWrite() */ void SyncPipe::releaseWrite() { - CALL("SyncPipe::releaseWrite"); ASS(isWriting()); _ostream->flush(); @@ -184,7 +177,6 @@ void SyncPipe::releaseWrite() */ void SyncPipe::neverWrite() { - CALL("SyncPipe::neverWrite"); ASS(canWrite()); //@b neverWrite() can only be called once ASS(!isWriting()); ASS(env.getOutputPipe()!=this); //we cannot forbid writing to pipe that we use as output @@ -207,7 +199,6 @@ void SyncPipe::neverWrite() */ void SyncPipe::releasePrivileges() { - CALL("SyncPipe::releasePrivileges"); ASS(_syncSemaphore.hasSemaphore()); if(isReading()) { @@ -225,8 +216,6 @@ void SyncPipe::releasePrivileges() */ void SyncPipe::postForkChildHadler() { - CALL("SyncPipe::postForkChildHadler"); - PipeList::Iterator pit(s_instances); while(pit.hasNext()) { SyncPipe* p=pit.next(); @@ -242,8 +231,6 @@ void SyncPipe::postForkChildHadler() */ void SyncPipe::terminationHadler() { - CALL("SyncPipe::terminationHadler"); - PipeList* listIter=s_instances; while(listIter) { if(listIter->head()) { @@ -257,8 +244,6 @@ void SyncPipe::terminationHadler() void SyncPipe::ensureEventHandlersInstalled() { - CALL("SyncPipe::ensureEventHandlersInstalled"); - static bool installed=false; if(installed) { return; diff --git a/Lib/System.cpp b/Lib/System.cpp index 282b50892..e4161b50e 100644 --- a/Lib/System.cpp +++ b/Lib/System.cpp @@ -30,7 +30,6 @@ #include #endif -#include "Debug/Tracer.hpp" #include "Shell/Options.hpp" #include "Shell/Statistics.hpp" @@ -93,8 +92,6 @@ const char* signalToString (int sigNum) */ void handleSignal (int sigNum) { - CALL("System::handleSignal"); - // true if a terminal signal has been handled already. // to avoid catching signals over and over again static bool handled = false; @@ -221,8 +218,6 @@ void System::setSignalHandlers() */ ZIArray*>& System::terminationHandlersArray() { - CALL("System::initializationHandlersArray"); - static ZIArray*> arr(2); return arr; } @@ -237,8 +232,6 @@ ZIArray*>& System::terminationHandlersArray() */ void System::addTerminationHandler(VoidFunc proc, unsigned priority) { - CALL("System::addTerminationHandler"); - VoidFuncList::push(proc, terminationHandlersArray()[priority]); } @@ -248,8 +241,6 @@ void System::addTerminationHandler(VoidFunc proc, unsigned priority) */ void System::onTermination() { - CALL("System::onTermination"); - static bool called=false; if(called) { return; @@ -269,8 +260,6 @@ void System::onTermination() void System::terminateImmediately(int resultStatus) { - CALL("System::terminateImmediately"); - onTermination(); _exit(resultStatus); } @@ -290,8 +279,6 @@ void System::registerForSIGHUPOnParentDeath() vstring System::extractFileNameFromPath(vstring str) { - CALL("System::extractFileNameFromPath"); - size_t index=str.find_last_of("\\/")+1; if(index==vstring::npos) { return str; @@ -307,8 +294,6 @@ vstring System::extractFileNameFromPath(vstring str) */ bool System::extractDirNameFromPath(vstring path, vstring& dir) { - CALL("System::extractDirNameFromPath"); - size_t index=path.find_last_of("\\/"); if(index==vstring::npos) { return false; @@ -319,7 +304,6 @@ bool System::extractDirNameFromPath(vstring path, vstring& dir) bool System::fileExists(vstring fname) { - CALL("System::fileExists"); BYPASSING_ALLOCATOR; ifstream ifile(fname.c_str()); @@ -329,8 +313,6 @@ bool System::fileExists(vstring fname) // C++17: use std::filesystem void System::readDir(vstring dirName, Stack& filenames) { - CALL("System::readDir"); - DIR *dirp; struct dirent *dp; diff --git a/Lib/TimeCounter.cpp b/Lib/TimeCounter.cpp index ca00bf757..08c7f83f2 100644 --- a/Lib/TimeCounter.cpp +++ b/Lib/TimeCounter.cpp @@ -13,7 +13,6 @@ */ #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" #include "Lib/Stack.hpp" @@ -43,8 +42,6 @@ TimeCounter* TimeCounter::s_currTop = 0; */ void TimeCounter::reinitialize() { - CALL("TimeCounter::reinitialize"); - s_measuring = true; s_initialized=0; @@ -63,7 +60,6 @@ void TimeCounter::reinitialize() void TimeCounter::initialize() { - CALL("TimeCounter::initialize"); ASS(!s_initialized); s_initialized=true; @@ -85,7 +81,6 @@ void TimeCounter::initialize() void TimeCounter::startMeasuring(TimeCounterUnit tcu) { - CALL("TimeCounter::startMeasuring"); ASS_NEQ(tcu, TC_OTHER); TimeoutProtector tp; // let's not get interrupted while updating our TimeCounter linked-list @@ -111,8 +106,6 @@ void TimeCounter::startMeasuring(TimeCounterUnit tcu) void TimeCounter::stopMeasuring() { - CALL("TimeCounter::stopMeasuring"); - TimeoutProtector tp; // let's not get interrupted while updating our TimeCounter linked-list if(_tcu==__TC_NONE) { @@ -138,8 +131,6 @@ void TimeCounter::stopMeasuring() void TimeCounter::snapShot() { - CALL("TimeCounter::snapShot"); - int currTime=env.timer->elapsedMilliseconds(); TimeCounter* counter = s_currTop; @@ -165,8 +156,6 @@ void TimeCounter::snapShot() void TimeCounter::printReport(ostream& out) { - CALL("TimeCounter::printReport"); - snapShot(); addCommentSignForSZS(out); diff --git a/Lib/Timer.cpp b/Lib/Timer.cpp index 0c6c991cd..b0da05d96 100644 --- a/Lib/Timer.cpp +++ b/Lib/Timer.cpp @@ -160,7 +160,6 @@ timer_sigalrm_handler (int sig) /** number of miliseconds (of CPU time) passed since some moment */ int Timer::miliseconds() { - CALL("Timer::miliseconds"); ASS_GE(timer_sigalrm_counter, 0); return timer_sigalrm_counter; @@ -223,8 +222,6 @@ long perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int g void Timer::ensureTimerInitialized() { - CALL("Timer::ensureTimerInitialized"); - // When ensureTimerInitialized is called, env.options->instructionLimit() will not be set yet, // so we do this init unconditionally resetInstructionMeasuring(); @@ -252,8 +249,6 @@ void Timer::ensureTimerInitialized() void Timer::resetInstructionMeasuring() { #ifdef __linux__ // if available, initialize the perf reading - CALL("Timer::resetInstructionMeasuring"); - /* * NOTE: we need to do this before initializing the actual timer * (otherwise timer_sigalrm_handler could start asking the uninitialized perf_fd!) @@ -295,8 +290,6 @@ bool Timer::instructionLimitingInPlace() void Timer::deinitializeTimer() { - CALL("Timer::deinitializeTimer"); - itimerval tv1, tv2; tv1.it_value.tv_usec=0; tv1.it_value.tv_sec=0; @@ -344,9 +337,6 @@ vstring Timer::msToSecondsString(int ms) */ void Timer::printMSString(ostream& str, int ms) { - //having the call macro here distorts the stacks printouts -// CALL("Timer::printMSString"); - if(ms<0) { str << '-'; ms = -ms; diff --git a/Lib/Vector.hpp b/Lib/Vector.hpp index d849bef33..29e3614ac 100644 --- a/Lib/Vector.hpp +++ b/Lib/Vector.hpp @@ -63,7 +63,6 @@ class Vector /** allocate a vector of the size @b length */ static Vector* allocate(size_t length) { - CALL("Vector::allocate"); ASS_G(length,0); size_t sz=sizeof(Vector) + (length-1)*sizeof(C); @@ -79,8 +78,6 @@ class Vector /** deallocate the vector */ void deallocate() { - CALL("Vector::deallocate"); - // in the case C is a class with an initialiser, apply the destructor of it // to every element of the allocated array array_delete(_array, _length); @@ -90,8 +87,6 @@ class Vector bool operator==(const Vector& v) const { - CALL("Vector::operator=="); - if(length()!=v.length()) { return false; } @@ -149,7 +144,6 @@ class Vector C next() { - CALL("Vector::DestructiveIterator::next"); ASS(hasNext()); C res=*cur; diff --git a/Lib/VirtualIterator.hpp b/Lib/VirtualIterator.hpp index 50e89d747..01e7777a7 100644 --- a/Lib/VirtualIterator.hpp +++ b/Lib/VirtualIterator.hpp @@ -19,7 +19,6 @@ #include "Forwards.hpp" #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Allocator.hpp" #include "Exception.hpp" @@ -166,7 +165,6 @@ class VirtualIterator { inline VirtualIterator(const VirtualIterator& obj) : _core(obj._core) { - CALL("ViratualIterator(const&)") if(_core) { _core->_refCnt++; } @@ -175,7 +173,6 @@ class VirtualIterator { inline ~VirtualIterator() { - CALL("VirtualIterator::~VirtualIterator"); if(_core) { _core->_refCnt--; if(!_core->_refCnt) { @@ -185,8 +182,6 @@ class VirtualIterator { } VirtualIterator& operator=(const VirtualIterator& obj) { - CALL("VirtualIterator::operator="); - IteratorCore* oldCore=_core; _core=obj._core; if(_core) { @@ -213,8 +208,6 @@ class VirtualIterator { inline bool drop() { - CALL("VirtualIterator::drop"); - if(_core) { _core->_refCnt--; if(_core->_refCnt) { @@ -234,7 +227,6 @@ class VirtualIterator { inline bool hasNext() { - CALL("VirtualIterator::hasNext"); ASS(_core); return _core->hasNext(); @@ -248,7 +240,6 @@ class VirtualIterator { inline T next() { - CALL("VirtualIterator::next"); ASS(_core); return _core->next(); @@ -257,7 +248,6 @@ class VirtualIterator { /** Return true if the function @b size() can be called */ bool knowsSize() const { - CALL("VirtualIterator::knowsSize"); ASS(_core); return _core->knowsSize(); @@ -274,7 +264,6 @@ class VirtualIterator { */ size_t size() const { - CALL("VirtualIterator::size"); ASS(_core); ASS(knowsSize()); diff --git a/Minisat/simp/SimpSolver.cc b/Minisat/simp/SimpSolver.cc index ed4938c19..814fa6bed 100644 --- a/Minisat/simp/SimpSolver.cc +++ b/Minisat/simp/SimpSolver.cc @@ -27,7 +27,6 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #include "Minisat/simp/SimpSolver.h" #include "Minisat/utils/System.h" -#include "Debug/Tracer.hpp" #include "Debug/TimeProfiling.hpp" using namespace Minisat; @@ -70,8 +69,6 @@ SimpSolver::SimpSolver() : , bwdsub_assigns (0) , n_touched (0) { - CALL("SimpSolver::SimpSolver"); - vec dummy(1,lit_Undef); ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below. bwdsub_tmpunit = ca.alloc(dummy); @@ -81,13 +78,10 @@ SimpSolver::SimpSolver() : SimpSolver::~SimpSolver() { - CALL("SimpSolver::~SimpSolver"); } Var SimpSolver::newVar(lbool upol, bool dvar) { - CALL("SimpSolver::newVar"); - Var v = Solver::newVar(upol, dvar); frozen .insert(v, (char)false); @@ -105,8 +99,6 @@ Var SimpSolver::newVar(lbool upol, bool dvar) { void SimpSolver::releaseVar(Lit l) { - CALL("SimpSolver::releaseVar"); - assert(!isEliminated(var(l))); if (!use_simplification && var(l) >= max_simp_var) // Note: Guarantees that no references to this variable is @@ -120,8 +112,6 @@ void SimpSolver::releaseVar(Lit l) lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp) { - CALL("SimpSolver::solve_"); - vec extra_frozen; lbool result = l_True; @@ -164,8 +154,6 @@ lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp) bool SimpSolver::addClause_(vec& ps) { - CALL("SimpSolver::addClause_"); - #ifndef NDEBUG for (int i = 0; i < ps.size(); i++) assert(!isEliminated(var(ps[i]))); @@ -206,8 +194,6 @@ bool SimpSolver::addClause_(vec& ps) void SimpSolver::removeClause(CRef cr) { - CALL("SimpSolver::removeClause"); - const Clause& c = ca[cr]; if (use_simplification) @@ -224,8 +210,6 @@ static const int LAZYNESS_TRESHOLD = 1000; bool SimpSolver::strengthenClause(CRef cr, Lit l, bool& was_lazy) { - CALL("SimpSolver::strengthenClause"); - Clause& c = ca[cr]; assert(decisionLevel() == 0); assert(use_simplification); @@ -300,8 +284,6 @@ bool SimpSolver::strengthenClause(CRef cr, Lit l, bool& was_lazy) // Returns FALSE if clause is always satisfied ('out_clause' should not be used). bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& out_clause) { - CALL("SimpSolver::merge(... out_clause)"); - merges++; out_clause.clear(); @@ -334,8 +316,6 @@ bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& ou // Returns FALSE if clause is always satisfied. bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size) { - CALL("SimpSolver::merge(... size)"); - merges++; bool ps_smallest = _ps.size() < _qs.size(); @@ -366,8 +346,6 @@ bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size) void SimpSolver::gatherTouchedClauses() { - CALL("SimpSolver::gatherTouchedClauses"); - if (n_touched == 0) return; int i,j; @@ -396,8 +374,6 @@ void SimpSolver::gatherTouchedClauses() bool SimpSolver::implied(const vec& c) { - CALL("SimpSolver::implied"); - assert(decisionLevel() == 0); trail_lim.push(trail.size()); @@ -419,8 +395,6 @@ bool SimpSolver::implied(const vec& c) // Backward subsumption + backward subsumption resolution bool SimpSolver::backwardSubsumptionCheck(bool verbose) { - CALL("SimpSolver::backwardSubsumptionCheck"); - TIME_TRACE("minisat bwd subsumption check"); int cnt = 0; @@ -500,8 +474,6 @@ bool SimpSolver::backwardSubsumptionCheck(bool verbose) bool SimpSolver::asymm(Var v, CRef cr) { - CALL("SimpSolver::asymm"); - Clause& c = ca[cr]; assert(decisionLevel() == 0); @@ -533,8 +505,6 @@ bool SimpSolver::asymm(Var v, CRef cr) bool SimpSolver::asymmVar(Var v) { - CALL("SimpSolver::asymmVar"); - assert(use_simplification); const vec& cls = occurs.lookup(v); @@ -585,8 +555,6 @@ static void mkElimClause(vec& elimclauses, Var v, Clause& c) bool SimpSolver::eliminateVar(Var v) { - CALL("SimpSolver::eliminateVar"); - { TIME_TRACE("minisat eliminate var"); @@ -652,8 +620,6 @@ bool SimpSolver::eliminateVar(Var v) bool SimpSolver::substitute(Var v, Lit x) { - CALL("SimpSolver::substitute"); - assert(!frozen[v]); assert(!isEliminated(v)); assert(value(v) == l_Undef); @@ -686,8 +652,6 @@ bool SimpSolver::substitute(Var v, Lit x) void SimpSolver::extendModel() { - CALL("SimpSolver::extendModel"); - int i, j; Lit x; @@ -705,8 +669,6 @@ void SimpSolver::extendModel() bool SimpSolver::eliminate(bool turn_off_elim) { - CALL("SimpSolver::eliminate"); - if (!simplify()) return false; else if (!use_simplification) @@ -796,8 +758,6 @@ bool SimpSolver::eliminate(bool turn_off_elim) void SimpSolver::relocAll(ClauseAllocator& to) { - CALL("SimpSolver::relocAll"); - if (!use_simplification) return; // All occurs lists: @@ -826,8 +786,6 @@ void SimpSolver::relocAll(ClauseAllocator& to) void SimpSolver::garbageCollect() { - CALL("SimpSolver::garbageCollect"); - // Initialize the next region to a size corresponding to the estimated utilization degree. This // is not precise but should avoid some unnecessary reallocations for the new region: ClauseAllocator to(ca.size() - ca.wasted()); diff --git a/Parse/SMTLIB2.cpp b/Parse/SMTLIB2.cpp index 7c9be33c6..188439c65 100644 --- a/Parse/SMTLIB2.cpp +++ b/Parse/SMTLIB2.cpp @@ -66,13 +66,10 @@ SMTLIB2::SMTLIB2(const Options& opts) _formulas(nullptr), _topLevelExpr(nullptr) { - CALL("SMTLIB2::SMTLIB2"); } void SMTLIB2::parse(istream& str) { - CALL("SMTLIB2::parse(istream&)"); - LispLexer lex(str); LispParser lpar(lex); LExpr* expr = lpar.parse(); @@ -81,15 +78,12 @@ void SMTLIB2::parse(istream& str) void SMTLIB2::parse(LExpr* bench) { - CALL("SMTLIB2::parse(LExpr*)"); - ASS(bench->isList()); readBenchmark(bench->list); } void SMTLIB2::readBenchmark(LExprList* bench) { - CALL("SMTLIB2::readBenchmark"); LispListReader bRdr(bench); bool afterCheckSat = false; @@ -456,8 +450,6 @@ const char * SMTLIB2::s_smtlibLogicNameStrings[] = { SMTLIBLogic SMTLIB2::getLogicFromString(const vstring& str) { - CALL("SMTLIB2::getLogicFromString"); - static NameArray smtlibLogicNames(s_smtlibLogicNameStrings, sizeof(s_smtlibLogicNameStrings)/sizeof(char*)); ASS_EQ(smtlibLogicNames.length, SMT_UNDEFINED); @@ -470,8 +462,6 @@ SMTLIBLogic SMTLIB2::getLogicFromString(const vstring& str) void SMTLIB2::readLogic(const vstring& logicStr) { - CALL("SMTLIB2::checkLogic"); - _logic = getLogicFromString(logicStr); _logicSet = true; @@ -547,8 +537,6 @@ void SMTLIB2::readLogic(const vstring& logicStr) void SMTLIB2::readDeclareSort(const vstring& name, const vstring& arity) { - CALL("SMTLIB2::readDeclareSort"); - vstring pName = name + TYPECON_POSTFIX; if (isAlreadyKnownSymbol(pName)) { USER_ERROR_EXPR("Redeclaring built-in, declared or defined sort symbol: "+name); @@ -572,8 +560,6 @@ void SMTLIB2::readDeclareSort(const vstring& name, const vstring& arity) void SMTLIB2::readDefineSort(const vstring& name, LExprList* args, LExpr* body) { - CALL("SMTLIB2::readDefineSort"); - vstring pName = name + TYPECON_POSTFIX; if (isAlreadyKnownSymbol(pName)) { USER_ERROR_EXPR("Redeclaring built-in, declared or defined sort symbol: "+name); @@ -623,8 +609,6 @@ const char * SMTLIB2::s_formulaSymbolNameStrings[] = { SMTLIB2::FormulaSymbol SMTLIB2::getBuiltInFormulaSymbol(const vstring& str) { - CALL("SMTLIB::getFormulaSymbol"); - static NameArray formulaSymbolNames(s_formulaSymbolNameStrings, sizeof(s_formulaSymbolNameStrings)/sizeof(char*)); ASS_EQ(formulaSymbolNames.length, FS_USER_PRED_SYMBOL); @@ -661,8 +645,6 @@ const char * SMTLIB2::s_termSymbolNameStrings[] = { SMTLIB2::TermSymbol SMTLIB2::getBuiltInTermSymbol(const vstring& str) { - CALL("SMTLIB::getTermSymbol"); - static NameArray termSymbolNames(s_termSymbolNameStrings, sizeof(s_termSymbolNameStrings)/sizeof(char*)); ASS_EQ(termSymbolNames.length, TS_USER_FUNCTION); @@ -675,8 +657,6 @@ SMTLIB2::TermSymbol SMTLIB2::getBuiltInTermSymbol(const vstring& str) bool SMTLIB2::isAlreadyKnownSymbol(const vstring& name) { - CALL("SMTLIB2::isAlreadyKnownSymbol"); - if (getBuiltInFormulaSymbol(name) != FS_USER_PRED_SYMBOL) { return true; } @@ -694,8 +674,6 @@ bool SMTLIB2::isAlreadyKnownSymbol(const vstring& name) void SMTLIB2::readDeclareFun(const vstring& name, LExprList* iSorts, LExpr* oSort, unsigned taArity) { - CALL("SMTLIB2::readDeclareFun"); - if (isAlreadyKnownSymbol(name)) { USER_ERROR_EXPR("Redeclaring function symbol: "+name); } @@ -716,8 +694,6 @@ void SMTLIB2::readDeclareFun(const vstring& name, LExprList* iSorts, LExpr* oSor SMTLIB2::DeclaredSymbol SMTLIB2::declareFunctionOrPredicate(const vstring& name, TermList rangeSort, const TermStack& argSorts, unsigned taArity) { - CALL("SMTLIB2::declareFunctionOrPredicate"); - bool added = false; unsigned symNum; Signature::Symbol* sym; @@ -763,8 +739,6 @@ SMTLIB2::DeclaredSymbol SMTLIB2::declareFunctionOrPredicate(const vstring& name, void SMTLIB2::readDefineFun(const vstring& name, LExprList* iArgs, LExpr* oSort, LExpr* body, const TermStack& typeArgs, bool recursive) { - CALL("SMTLIB2::readDefineFun"); - if (isAlreadyKnownSymbol(name)) { USER_ERROR_EXPR("Redeclaring function symbol: "+name); } @@ -843,8 +817,6 @@ void SMTLIB2::readDefineFun(const vstring& name, LExprList* iArgs, LExpr* oSort, void SMTLIB2::readTypeParameters(LispListReader& rdr, TermLookup* lookup, TermStack* ts) { - CALL("SMTLIB2::readTypeParameters"); - if (!rdr.hasNext()) { USER_ERROR_EXPR("'par' keyword must be followed by a list of parameters"); } @@ -870,8 +842,6 @@ void SMTLIB2::readTypeParameters(LispListReader& rdr, TermLookup* lookup, TermSt void SMTLIB2::readDeclareDatatype(LExpr *sort, LExprList *datatype) { - CALL("SMTLIB2::readDeclareDatatype"); - // first declare the sort vstring dtypeName = sort->str+TYPECON_POSTFIX; if (isAlreadyKnownSymbol(dtypeName)) { @@ -943,8 +913,6 @@ void SMTLIB2::readDeclareDatatype(LExpr *sort, LExprList *datatype) void SMTLIB2::readDeclareDatatypes(LExprList* sorts, LExprList* datatypes, bool codatatype) { - CALL("SMTLIB2::readDeclareDatatypes"); - if(LExprList::length(sorts) != LExprList::length(datatypes)){ USER_ERROR_EXPR("declare-datatype(s) declaration mismatch between declared datatypes and definitions"); } @@ -1033,8 +1001,6 @@ void SMTLIB2::readDeclareDatatypes(LExprList* sorts, LExprList* datatypes, bool TermAlgebraConstructor* SMTLIB2::buildTermAlgebraConstructor(vstring constrName, TermList taSort, Stack destructorNames, TermStack argSorts) { - CALL("SMTLIB2::buildTermAlgebraConstructor"); - if (isAlreadyKnownSymbol(constrName)) { USER_ERROR_EXPR("Redeclaring function symbol: " + constrName); } @@ -1090,8 +1056,6 @@ TermAlgebraConstructor* SMTLIB2::buildTermAlgebraConstructor(vstring constrName, bool SMTLIB2::ParseResult::asFormula(Formula*& resFrm) { - CALL("SMTLIB2::ParseResult::asFormula"); - if (formula) { ASS_EQ(sort, AtomicSort::boolSort()); resFrm = attachLabelToFormula(frm); @@ -1127,8 +1091,6 @@ bool SMTLIB2::ParseResult::asFormula(Formula*& resFrm) TermList SMTLIB2::ParseResult::asTerm(TermList& resTrm) { - CALL("SMTLIB2::ParseResult::asTerm"); - if (formula) { ASS_EQ(sort, AtomicSort::boolSort()); @@ -1151,7 +1113,6 @@ TermList SMTLIB2::ParseResult::asTerm(TermList& resTrm) vstring SMTLIB2::ParseResult::toString() { - CALL("SMTLIB2::ParseResult::toString"); if (isSeparator()) { return "separator"; } @@ -1171,8 +1132,6 @@ Formula* SMTLIB2::ParseResult::attachLabelToFormula(Formula* frm) Interpretation SMTLIB2::getFormulaSymbolInterpretation(FormulaSymbol fs, TermList firstArgSort) { - CALL("SMTLIB2::getFormulaSymbolInterpretation"); - switch(fs) { case FS_LESS: if(firstArgSort == AtomicSort::intSort()){ @@ -1211,8 +1170,6 @@ Interpretation SMTLIB2::getFormulaSymbolInterpretation(FormulaSymbol fs, TermLis Interpretation SMTLIB2::getUnaryMinusInterpretation(TermList argSort) { - CALL("SMTLIB2::getUnaryMinusInterpretation"); - if(argSort == AtomicSort::intSort()){ return Theory::INT_UNARY_MINUS; } else if(argSort == AtomicSort::realSort()) { @@ -1224,8 +1181,6 @@ Interpretation SMTLIB2::getUnaryMinusInterpretation(TermList argSort) Interpretation SMTLIB2::getTermSymbolInterpretation(TermSymbol ts, TermList firstArgSort) { - CALL("SMTLIB2::getTermSymbolInterpretation"); - switch(ts) { case TS_MINUS: if(firstArgSort == AtomicSort::intSort()){ @@ -1267,15 +1222,11 @@ Interpretation SMTLIB2::getTermSymbolInterpretation(TermSymbol ts, TermList firs void SMTLIB2::complainAboutArgShortageOrWrongSorts(const vstring& symbolClass, LExpr* exp) { - CALL("SMTLIB2::complainAboutArgShortageOrWrongSorts"); - USER_ERROR_EXPR("Not enough arguments or wrong sorts for "+symbolClass+" application '"+exp->toString()+"'"); } void SMTLIB2::parseLetBegin(LExpr* exp) { - CALL("SMTLIB2::parseLetBegin"); - LOG2("parseLetBegin ",exp->toString()); ASS(exp->isList()); @@ -1323,7 +1274,6 @@ void SMTLIB2::parseLetBegin(LExpr* exp) void SMTLIB2::parseLetPrepareLookup(LExpr* exp) { - CALL("SMTLIB2::parseLetPrepareLookup"); LOG2("PO_LET_PREPARE_LOOKUP",exp->toString()); // so we know it is let @@ -1413,7 +1363,6 @@ void SMTLIB2::parseLetPrepareLookup(LExpr* exp) void SMTLIB2::parseLetEnd(LExpr* exp) { - CALL("SMTLIB2::parseLetEnd"); LOG2("PO_LET_END ",exp->toString()); // so we know it is let @@ -1474,8 +1423,6 @@ static const char *UNDERSCORE = "_"; bool SMTLIB2::isTermAlgebraConstructor(const vstring &name) { - CALL("SMTLIB2::isTermAlgebraConstructor"); - if (_declaredSymbols.find(name)) { DeclaredSymbol &s = _declaredSymbols.get(name); return (s.second==SymbolType::FUNCTION && env.signature->getTermAlgebraConstructor(s.first)); @@ -1486,8 +1433,6 @@ bool SMTLIB2::isTermAlgebraConstructor(const vstring &name) void SMTLIB2::parseMatchBegin(LExpr *exp) { - CALL("SMTLIB2::parseMatchBegin"); - LOG2("parseMatchBegin ", exp->toString()); ASS(exp->isList()); @@ -1562,8 +1507,6 @@ void SMTLIB2::parseMatchBegin(LExpr *exp) void SMTLIB2::parseMatchCaseStart(LExpr *exp) { - CALL("SMTLIB2::parseMatchCaseStart"); - ASS(exp->isList()); LispListReader eRdr(exp->list); @@ -1631,8 +1574,6 @@ void SMTLIB2::parseMatchCaseStart(LExpr *exp) void SMTLIB2::parseMatchCaseEnd(LExpr *exp) { - CALL("SMTLIB2::parseMatchCaseEnd"); - LExprList::destroy(exp->list); delete exp; delete _scopes.pop(); @@ -1640,8 +1581,6 @@ void SMTLIB2::parseMatchCaseEnd(LExpr *exp) void SMTLIB2::parseMatchEnd(LExpr *exp) { - CALL("SMTLIB2::parseMatchEnd"); - LOG2("PO_MATCH_END ", exp->toString()); ASS(exp->isList()); @@ -1747,8 +1686,6 @@ void SMTLIB2::parseMatchEnd(LExpr *exp) void SMTLIB2::parseQuantBegin(LExpr* exp) { - CALL("SMTLIB2::parseQuantBegin"); - ASS(exp->isList()); LispListReader lRdr(exp->list); @@ -1780,8 +1717,6 @@ void SMTLIB2::parseQuantBegin(LExpr* exp) void SMTLIB2::parseQuantEnd(LExpr* exp) { - CALL("SMTLIB2::parseQuantEnd"); - ASS(exp->isList()); LispListReader lRdr(exp->list); @@ -1828,8 +1763,6 @@ void SMTLIB2::parseQuantEnd(LExpr* exp) void SMTLIB2::parseParametric(LExpr* exp) { - CALL("SMTLIB2::parseParametric"); - ASS(exp->isList()); LispListReader lRdr(exp->list); @@ -1852,8 +1785,6 @@ static const char* EXCLAMATION = "!"; void SMTLIB2::parseAnnotatedTerm(LExpr* exp) { - CALL("SMTLIB2::parseAnnotatedTerm"); - ASS(exp->isList()); LispListReader lRdr(exp->list); @@ -1888,8 +1819,6 @@ void SMTLIB2::parseAnnotatedTerm(LExpr* exp) bool SMTLIB2::parseAsScopeLookup(const vstring& id) { - CALL("SMTLIB2::parseAsScopeLookup"); - Scopes::Iterator sIt(_scopes); while (sIt.hasNext()) { TermLookup* lookup = sIt.next(); @@ -1906,7 +1835,6 @@ bool SMTLIB2::parseAsScopeLookup(const vstring& id) bool SMTLIB2::parseAsSortDefinition(const vstring& id,LExpr* exp) { - CALL("SMTLIB2::parseAsSortDefinition"); vstring pId = id + TYPECON_POSTFIX; auto def = _sortDefinitions.findPtr(pId); if (!def) { @@ -1938,8 +1866,6 @@ bool SMTLIB2::parseAsSortDefinition(const vstring& id,LExpr* exp) bool SMTLIB2::parseAsSpecConstant(const vstring& id) { - CALL("SMTLIB2::parseAsSpecConstant"); - if (StringUtils::isPositiveInteger(id)) { if (_numeralsAreReal) { goto real_constant; // just below @@ -1967,8 +1893,6 @@ bool SMTLIB2::parseAsSpecConstant(const vstring& id) bool SMTLIB2::parseAsUserDefinedSymbol(const vstring& id,LExpr* exp,bool isSort) { - CALL("SMTLIB2::parseAsUserDefinedSymbol"); - DeclaredSymbol sym; if (!_declaredSymbols.find(id+(isSort?TYPECON_POSTFIX:""),sym)) { return false; @@ -2055,8 +1979,6 @@ static const char* BUILT_IN_SYMBOL = "built-in symbol"; bool SMTLIB2::parseAsBuiltinFormulaSymbol(const vstring& id, LExpr* exp) { - CALL("SMTLIB2::parseAsBuiltinFormulaSymbol"); - FormulaSymbol fs = getBuiltInFormulaSymbol(id); switch (fs) { case FS_TRUE: @@ -2340,8 +2262,6 @@ bool SMTLIB2::parseAsBuiltinFormulaSymbol(const vstring& id, LExpr* exp) bool SMTLIB2::parseAsBuiltinTermSymbol(const vstring& id, LExpr* exp) { - CALL("SMTLIB2::parseAsBuiltinTermSymbol"); - // try built-in term symbols TermSymbol ts = getBuiltInTermSymbol(id); switch(ts) { @@ -2581,8 +2501,6 @@ bool SMTLIB2::parseAsBuiltinTermSymbol(const vstring& id, LExpr* exp) void SMTLIB2::parseRankedFunctionApplication(LExpr* exp) { - CALL("SMTLIB2::parseRankedFunctionApplication"); - ASS(exp->isList()); LispListReader lRdr(exp->list); LExpr* head = lRdr.readNext(); @@ -2656,8 +2574,6 @@ void SMTLIB2::parseRankedFunctionApplication(LExpr* exp) SMTLIB2::ParseResult SMTLIB2::parseTermOrFormula(LExpr* body, bool isSort) { - CALL("SMTLIB2::parseTermOrFormula"); - ASS(_todo.isEmpty()); ASS(_results.isEmpty()); @@ -2898,8 +2814,6 @@ SMTLIB2::ParseResult SMTLIB2::parseTermOrFormula(LExpr* body, bool isSort) void SMTLIB2::readAssert(LExpr* body) { - CALL("SMTLIB2::readAssert"); - _nextVar = 0; ASS(_scopes.isEmpty()); @@ -2916,8 +2830,6 @@ void SMTLIB2::readAssert(LExpr* body) void SMTLIB2::readAssertNot(LExpr* body) { - CALL("SMTLIB2::readAssert"); - _nextVar = 0; ASS(_scopes.isEmpty()); @@ -2936,8 +2848,6 @@ void SMTLIB2::readAssertNot(LExpr* body) void SMTLIB2::readAssertTheory(LExpr* body) { - CALL("SMTLIB2::readAssertTheory"); - _nextVar = 0; ASS(_scopes.isEmpty()); @@ -2954,8 +2864,6 @@ void SMTLIB2::readAssertTheory(LExpr* body) void SMTLIB2::colorSymbol(const vstring& name, Color color) { - CALL("SMTLIB2::colorSymbol"); - if (!_declaredSymbols.find(name)) { USER_ERROR_EXPR("'"+name+"' is not a user symbol"); } diff --git a/Parse/TPTP.cpp b/Parse/TPTP.cpp index c1d24ce32..dbae3a633 100644 --- a/Parse/TPTP.cpp +++ b/Parse/TPTP.cpp @@ -17,7 +17,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Int.hpp" #include "Lib/Environment.hpp" @@ -114,8 +113,6 @@ TPTP::~TPTP() */ void TPTP::parse() { - CALL("TPTP::parse"); - // bulding tokens one by one _gpos = 0; _cend = 0; @@ -428,8 +425,6 @@ vstring TPTP::toString(Tag tag) */ bool TPTP::readToken(Token& tok) { - CALL("TPTP::readToken"); - skipWhiteSpacesAndComments(); tok.start = _gpos; switch (getChar(0)) { @@ -700,8 +695,6 @@ bool TPTP::readToken(Token& tok) */ void TPTP::skipWhiteSpacesAndComments() { - CALL("TPTP::skipWhiteSpacesAndComments"); - for (;;) { switch (getChar(0)) { case 0: // end-of-file @@ -786,7 +779,6 @@ void TPTP::skipWhiteSpacesAndComments() */ void TPTP::readName(Token& tok) { - CALL("TPTP::readName"); for (int n = 1;;n++) { switch (getChar(n)) { case 'A': @@ -869,8 +861,6 @@ void TPTP::readName(Token& tok) */ void TPTP::readReserved(Token& tok) { - CALL("TPTP::readReserved"); - int n = 1; for (;;n++) { switch (getChar(n)) { @@ -1027,7 +1017,6 @@ void TPTP::readReserved(Token& tok) */ void TPTP::readString(Token& tok) { - CALL("TPTP::readString"); for (int n = 1;;n++) { int c = getChar(n); if (!c) { @@ -1054,8 +1043,6 @@ void TPTP::readString(Token& tok) */ void TPTP::readAtom(Token& tok) { - CALL("TPTP::readAtom"); - for (int n = 1;;n++) { int c = getChar(n); if (!c) { @@ -1102,8 +1089,6 @@ void TPTP::ParseErrorException::cry(ostream& str) const */ TPTP::Tag TPTP::readNumber(Token& tok) { - CALL("TPTP::readNumber"); - // skip the sign int c = getChar(0); ASS(c); @@ -1157,8 +1142,6 @@ TPTP::Tag TPTP::readNumber(Token& tok) */ int TPTP::decimal(int pos) { - CALL("TPTP::decimal"); - switch (getChar(pos)) { case '0': return pos+1; @@ -1191,8 +1174,6 @@ int TPTP::decimal(int pos) */ int TPTP::positiveDecimal(int pos) { - CALL("TPTP::positiveDecimal"); - switch (getChar(pos)) { case '1': case '2': @@ -1223,7 +1204,6 @@ int TPTP::positiveDecimal(int pos) */ void TPTP::unitList() { - CALL("TPTP::unitList"); if (env.timeLimitReached()) { // empty states to avoid infinite loop while (!_states.isEmpty()) { @@ -1301,8 +1281,6 @@ void TPTP::unitList() */ void TPTP::fof(bool fo) { - CALL("TPTP::fof"); - _bools.push(fo); consumeToken(T_LPAR); // save the name of this unit @@ -1384,8 +1362,6 @@ void TPTP::fof(bool fo) */ void TPTP::tff() { - CALL("TPTP::tff"); - consumeToken(T_LPAR); // save the name of this unit Token& tok = getTok(0); @@ -1501,8 +1477,6 @@ void TPTP::tff() unsigned TPTP::getConstructorArity() { - CALL("TPTP::getConstructorArity"); - unsigned arity = 0; Token tok = getTok(0); while(tok.tag == T_ARROW || tok.tag == T_TTYPE){ @@ -1521,7 +1495,6 @@ unsigned TPTP::getConstructorArity() void TPTP::holFormula() { - CALL("TPTP::holFunction"); Token tok = getTok(0); switch (tok.tag) { @@ -1635,7 +1608,6 @@ void TPTP::holFormula() void TPTP::holTerm() { - CALL("TPTP::holTerm"); Token tok = getTok(0); resetToks(); @@ -1703,8 +1675,6 @@ void TPTP::holTerm() vstring TPTP::convert(Tag t) { - CALL("TPTP::convert(Tag t)"); - switch(t){ case T_AND: return "vAND"; @@ -1738,8 +1708,6 @@ vstring TPTP::convert(Tag t) void TPTP::endHolFormula() { - CALL("TPTP::endHolFormula"); - int con = _connectives.pop(); if (con == -2){ @@ -1954,8 +1922,6 @@ switch (tag) { */ void TPTP::endApp() { - CALL("TPTP::endApp"); - if(_lastPushed == FORM){ endFormulaInsideTerm(); } @@ -1983,8 +1949,6 @@ void TPTP::endApp() */ void TPTP::endIte() { - CALL("TPTP::endIte"); - TermList elseBranch = _termLists.pop(); TermList thenBranch = _termLists.pop(); Formula* condition = _formulas.pop(); @@ -2003,8 +1967,6 @@ void TPTP::endIte() * */ void TPTP::endTheoryFunction() { - CALL("TPTP::endTheoryFunction"); - /** * Things get a bit awkward with theories + FOOL, because theory function can * return $o in such case be a predicate symbol rather than a function symbol. @@ -2097,8 +2059,6 @@ void TPTP::endTheoryFunction() { */ void TPTP::include() { - CALL("TPTP::include"); - consumeToken(T_LPAR); Token& tok = getTok(0); if (tok.tag != T_NAME) { @@ -2161,7 +2121,6 @@ void TPTP::include() /** add a file name to the list of forbidden includes */ void TPTP::addForbiddenInclude(vstring file) { - CALL("TPTP::addForbiddenInclude"); _forbiddenIncludes.insert(file); } @@ -2171,7 +2130,6 @@ void TPTP::addForbiddenInclude(vstring file) */ vstring TPTP::name() { - CALL("TPTP::name"); Token& tok = getTok(0); if (tok.tag != T_NAME) { PARSE_ERROR("name expected",tok); @@ -2187,8 +2145,6 @@ vstring TPTP::name() */ void TPTP::consumeToken(Tag t) { - CALL("TPTP::consumeToken"); - Token& tok = getTok(0); if (tok.tag != t) { vstring expected = toString(t); @@ -2204,8 +2160,6 @@ void TPTP::consumeToken(Tag t) */ void TPTP::formula() { - CALL("TPTP::formula"); - if(_isThf){ _connectives.push(-2); //special connective for HOL funcs _connectives.push(-1); @@ -2225,7 +2179,6 @@ void TPTP::formula() */ void TPTP::termInfix() { - CALL("TPTP::termInfix"); Token tok = getTok(0); switch (tok.tag) { case T_EQUAL: @@ -2268,8 +2221,6 @@ void TPTP::termInfix() */ void TPTP::type() { - CALL("TPTP::type"); - _typeTags.push(TT_ATOMIC); _states.push(END_TYPE); _states.push(SIMPLE_TYPE); @@ -2281,7 +2232,6 @@ void TPTP::type() */ void TPTP::funApp() { - CALL("TPTP::funApp"); Token tok = getTok(0); resetToks(); @@ -2372,8 +2322,6 @@ void TPTP::funApp() void TPTP::letType() { - CALL("TPTP::letType"); - // We cannot use this method in TPTP::tff() because type declarations in the // "type" role TFF units allow declarations of types ($tType), which are not // allowed inside $lets @@ -2385,8 +2333,6 @@ void TPTP::letType() void TPTP::endLetTypes() { - CALL("TPTP::endLetTypes"); - vstring name = _strings.pop(); Type* t = _types.pop(); OperatorType* type = constructOperatorType(t); @@ -2427,8 +2373,6 @@ void TPTP::endLetTypes() void TPTP::definition() { - CALL("TPTP::definition"); - // At this point we parse one or more simultaneous definitions. // Simultaneous definitions are of the form `[D1, ..., Dn]` and each // definition is either of a function/predicate symbol `f(X,Y,Z) := t` @@ -2501,8 +2445,6 @@ void TPTP::definition() void TPTP::midDefinition() { - CALL("TPTP::midDefinition"); - switch (getTok(0).tag) { case T_NAME: _strings.push(name()); @@ -2521,8 +2463,6 @@ void TPTP::midDefinition() void TPTP::symbolDefinition() { - CALL("TPTP::symbolDefinition"); - vstring nm = _strings.pop(); unsigned arity = 0; VList* vs = VList::empty(); @@ -2598,8 +2538,6 @@ void TPTP::symbolDefinition() */ void TPTP::tupleDefinition() { - CALL("TPTP::tupleDefinition"); - Set uniqueConstants; Stack symbols; TermStack sorts; @@ -2656,8 +2594,6 @@ void TPTP::tupleDefinition() } // tupleDefinition void TPTP::endDefinition() { - CALL("TPTP::endDefinition"); - LetSymbolReference ref = _letDefinitions.top().top(); unsigned symbol = SYMBOL(ref); bool isPredicate = IS_PREDICATE(ref); @@ -2693,8 +2629,6 @@ void TPTP::endDefinition() { } // endDefinition bool TPTP::findLetSymbol(LetSymbolName symbolName, LetSymbolReference& symbolReference) { - CALL("TPTP::findLetSymbol(LetSymbolName,LetSymbolReference)"); - Stack::TopFirstIterator scopes(_letSymbols); while (scopes.hasNext()) { LetSymbols scope = scopes.next(); @@ -2706,7 +2640,6 @@ bool TPTP::findLetSymbol(LetSymbolName symbolName, LetSymbolReference& symbolRef } // findLetSymbol(LetSymbolName,LetSymbolReference) bool TPTP::findLetSymbol(LetSymbolName symbolName, LetSymbols scope, LetSymbolReference& symbolReference) { - CALL("TPTP::findLetSymbol(LetSymbolName,LetSymbols,LetSymbolReference)"); LetSymbols::Iterator symbols(scope); while (symbols.hasNext()) { LetSymbol symbol = symbols.next(); @@ -2725,8 +2658,6 @@ bool TPTP::findLetSymbol(LetSymbolName symbolName, LetSymbols scope, LetSymbolRe */ void TPTP::endLet() { - CALL("TPTP::endLet"); - TermList let = _termLists.pop(); TermList sort = sortOf(let); @@ -2762,8 +2693,6 @@ void TPTP::endLet() */ void TPTP::endTuple() { - CALL("TPTP::endTuple"); - unsigned arity = (unsigned)_ints.pop(); ASS_GE(_termLists.size(), arity); @@ -2787,7 +2716,6 @@ void TPTP::endTuple() */ void TPTP::args() { - CALL("TPTP::args"); _states.push(END_ARGS); _states.push(TERM); } // args @@ -2798,7 +2726,6 @@ void TPTP::args() */ void TPTP::endArgs() { - CALL("TPTP::endArgs"); // check if there is any other term in the argument list Token tok = getTok(0); switch (tok.tag) { @@ -2825,8 +2752,6 @@ void TPTP::endArgs() */ void TPTP::bindVariable(unsigned var,TermList sort) { - CALL("TPTP::bindVariable"); - SList** definitions; // definitions will be a pointer to the list inside _variableSorts, // either the one that was there, or a freshly inserted empty one @@ -2842,8 +2767,6 @@ void TPTP::bindVariable(unsigned var,TermList sort) */ void TPTP::varList() { - CALL("TPTP::varList"); - Stack vars; for (;;) { Token& tok = getTok(0); @@ -2902,7 +2825,6 @@ void TPTP::varList() */ void TPTP::term() { - CALL("TPTP::term"); Token tok = getTok(0); switch (tok.tag) { case T_NAME: @@ -2990,8 +2912,6 @@ void TPTP::term() */ void TPTP::endTerm() { - CALL("TPTP::endTerm"); - vstring name = _strings.pop(); if (name == toString(T_ITE)) { @@ -3051,8 +2971,6 @@ void TPTP::endTerm() */ void TPTP::formulaInfix() { - CALL("TPTP::formulaInfix"); - Token tok = getTok(0); if (tok.tag == T_EQUAL || tok.tag == T_NEQ) { @@ -3120,8 +3038,6 @@ void TPTP::formulaInfix() */ void TPTP::endEquality() { - CALL("TPTP::endEquality"); - _insideEqualityArgument--; if((_isThf) && (_lastPushed == FORM)){ @@ -3151,8 +3067,6 @@ void TPTP::endEquality() */ void TPTP::midEquality() { - CALL("TPTP::midEquality"); - _insideEqualityArgument++; Token tok = getTok(0); @@ -3204,7 +3118,6 @@ Literal* TPTP::createEquality(bool polarity,TermList& lhs,TermList& rhs) */ Formula* TPTP::createPredicateApplication(vstring name, unsigned arity) { - CALL("TPTP::createPredicateApplication"); ASS_GE(_termLists.size(), arity); int pred; @@ -3289,7 +3202,6 @@ Formula* TPTP::createPredicateApplication(vstring name, unsigned arity) */ TermList TPTP::createFunctionApplication(vstring name, unsigned arity) { //TODO update to deal with wierd /\ @ ... syntax - CALL("TPTP::createFunctionApplication"); ASS_GE(_termLists.size(), arity); unsigned fun; @@ -3343,7 +3255,6 @@ TermList TPTP::createFunctionApplication(vstring name, unsigned arity) */ TermList TPTP::createTypeConApplication(vstring name, unsigned arity) { - CALL("TPTP::createTypeConApplication"); ASS_GE(_termLists.size(), arity); bool dummy; @@ -3375,8 +3286,6 @@ TermList TPTP::createTypeConApplication(vstring name, unsigned arity) */ void TPTP::endFormula() { - CALL("TPTP::endFormula"); - int con = _connectives.pop(); Formula* f; bool conReverse = false; @@ -3538,7 +3447,6 @@ void TPTP::endFormula() */ void TPTP::formulaInsideTerm() { - CALL("TPTP::formulaInsideTerm"); _states.push(END_FORMULA_INSIDE_TERM); _states.push(FORMULA); } // formulaInsideTerm @@ -3550,7 +3458,6 @@ void TPTP::formulaInsideTerm() */ void TPTP::endFormulaInsideTerm() { - CALL("TPTP::endFormulaInsideTerm"); Formula* f = _formulas.pop(); TermList ts(Term::createFormula(f)); _termLists.push(ts); @@ -3564,7 +3471,6 @@ void TPTP::endFormulaInsideTerm() */ void TPTP::endTermAsFormula() { - CALL("TPTP::endTermAsFormula"); TermList t = _termLists.pop(); TermList tSort = sortOf(t); if (tSort != AtomicSort::boolSort()) { @@ -3585,8 +3491,6 @@ void TPTP::endTermAsFormula() */ void TPTP::endType() { - CALL("TPTP::endType"); - TypeTag tt = _typeTags.pop(); Type* t = _types.pop(); switch (tt) { @@ -3634,7 +3538,6 @@ void TPTP::endType() */ void TPTP::tag() { - CALL("TPTP::tag"); consumeToken(_tags.pop()); } // tag @@ -3644,8 +3547,6 @@ void TPTP::tag() */ void TPTP::endFof() { - CALL("TPTP::endFof"); - TPTP::SourceRecord* source = 0; // are we interested in collecting sources? @@ -3810,7 +3711,6 @@ void TPTP::endFof() */ void TPTP::addTagState(Tag t) { - CALL("TPTP::addTagState"); _states.push(TAG); _tags.push(t); } // TPTP::addTagState @@ -3821,8 +3721,6 @@ void TPTP::addTagState(Tag t) */ void TPTP::endTff() { - CALL("TPTP::endTff"); - int rpars= _ints.pop(); while (rpars--) { consumeToken(T_RPAR); @@ -3896,8 +3794,6 @@ void TPTP::endTff() OperatorType* TPTP::constructOperatorType(Type* t, VList* vars) { - CALL("TPTP::constructOperatorType"); - TermList resultSort; Stack argumentSorts; @@ -4143,8 +4039,6 @@ void TPTP::skipToRBRA() */ void TPTP::simpleFormula() { - CALL("TPTP::simpleFormula"); - Token tok = getTok(0); switch (tok.tag) { @@ -4215,8 +4109,6 @@ void TPTP::simpleFormula() */ void TPTP::unbindVariables() { - CALL("TPTP::unbindVariables"); - VList::Iterator vs(_bindLists.pop()); while (vs.hasNext()) { unsigned var = vs.next(); @@ -4232,8 +4124,6 @@ void TPTP::unbindVariables() */ void TPTP::simpleType() { - CALL("TPTP::simpleType"); - Token& tok = getTok(0); if(tok.tag == T_TYPE_QUANT) { @@ -4273,8 +4163,6 @@ void TPTP::simpleType() TermList TPTP::readArrowSort() { - CALL("TPTP::readArrowSort"); - int inBrackets = 0; TermStack terms; Token tok = getTok(0); @@ -4315,8 +4203,6 @@ TermList TPTP::readArrowSort() void TPTP::foldl(TermStack* terms) { - CALL("TPTP::foldl"); - TermList item1 = terms->pop(); TermList item2 = terms->pop(); while(!(terms->isEmpty()) && (!item2.isSpecialVar())){ @@ -4331,8 +4217,6 @@ void TPTP::foldl(TermStack* terms) void TPTP::readTypeArgs(unsigned arity) { - CALL("TPTP::readTypeArgs"); - for(unsigned i = 0; i < arity; i++){ consumeToken(T_APP); Token tok = getTok(0); @@ -4354,8 +4238,6 @@ void TPTP::readTypeArgs(unsigned arity) */ TermList TPTP::readSort() { - CALL("TPTP::readSort"); - Token tok = getTok(0); resetToks(); switch (tok.tag) { @@ -4482,8 +4364,6 @@ bool TPTP::higherPrecedence(int c1,int c2) } // higherPriority bool TPTP::findInterpretedPredicate(vstring name, unsigned arity) { - CALL("TPTP::findInterpretedPredicate"); - if (name == "$evaleq" || name == "$equal" || name == "$distinct") { return true; } @@ -4538,8 +4418,6 @@ Formula* TPTP::makeJunction (Connective c,Formula* lhs,Formula* rhs) */ unsigned TPTP::addFunction(vstring name,int arity,bool& added,TermList& arg) { - CALL("TPTP::addFunction"); - if (name == "$sum") { return addOverloadedFunction(name,arity,2,added,arg, Theory::INT_PLUS, @@ -4705,8 +4583,6 @@ unsigned TPTP::addFunction(vstring name,int arity,bool& added,TermList& arg) */ int TPTP::addPredicate(vstring name,int arity,bool& added,TermList& arg) { - CALL("TPTP::addPredicate"); - if (name == "$evaleq" || name == "$equal") { return -1; } @@ -4767,8 +4643,6 @@ unsigned TPTP::addOverloadedFunction(vstring name,int arity,int symbolArity,bool Theory::Interpretation integer,Theory::Interpretation rational, Theory::Interpretation real) { - CALL("TPTP::addOverloadedFunction"); - if (arity != symbolArity) { USER_ERROR(name + " is used with " + Int::toString(arity) + " argument(s) when there were "+Int::toString(symbolArity)+" expected"); } @@ -4799,8 +4673,6 @@ unsigned TPTP::addOverloadedPredicate(vstring name,int arity,int symbolArity,boo Theory::Interpretation integer,Theory::Interpretation rational, Theory::Interpretation real) { - CALL("TPTP::addOverloadedPredicate"); - if (arity != symbolArity) { USER_ERROR(name + " is used with " + Int::toString(arity) + " argument(s) when there were "+Int::toString(symbolArity)+" expected"); } @@ -4836,8 +4708,6 @@ unsigned TPTP::addOverloadedPredicate(vstring name,int arity,int symbolArity,boo */ TermList TPTP::sortOf(TermList t) { - CALL("TPTP::sortOf"); - for (;;) { if (t.isVar()) { SList* sorts; @@ -4872,8 +4742,6 @@ TermList TPTP::sortOf(TermList t) */ unsigned TPTP::addIntegerConstant(const vstring& name, Set& overflow, bool defaultSort) { - CALL("TPTP::addIntegerConstant"); - try { return env.signature->addIntegerConstant(name,defaultSort); } @@ -4904,8 +4772,6 @@ unsigned TPTP::addIntegerConstant(const vstring& name, Set& overflow, b */ unsigned TPTP::addRationalConstant(const vstring& name, Set& overflow, bool defaultSort) { - CALL("TPTP::addRationalConstant"); - size_t i = name.find_first_of("/"); ASS(i != vstring::npos); try { @@ -4940,8 +4806,6 @@ unsigned TPTP::addRationalConstant(const vstring& name, Set& overflow, */ unsigned TPTP::addRealConstant(const vstring& name, Set& overflow, bool defaultSort) { - CALL("TPTP::addRealConstant"); - try { return env.signature->addRealConstant(name,defaultSort); } @@ -4969,8 +4833,6 @@ unsigned TPTP::addRealConstant(const vstring& name, Set& overflow, bool */ unsigned TPTP::addUninterpretedConstant(const vstring& name, Set& overflow, bool& added) { - CALL("TPTP::addUninterpretedConstant"); - if (overflow.contains(name)) { USER_ERROR((vstring)"Cannot use name '" + name + "' as an atom name since it collides with an integer number"); } @@ -4991,7 +4853,6 @@ unsigned TPTP::addUninterpretedConstant(const vstring& name, Set& overf */ void TPTP::assignAxiomName(const Unit* unit, vstring& name) { - CALL("Parser::assignAxiomName"); ALWAYS(_axiomNames.insert(unit->number(), name)); } // TPTP::assignAxiomName @@ -5001,7 +4862,6 @@ void TPTP::assignAxiomName(const Unit* unit, vstring& name) */ bool TPTP::findAxiomName(const Unit* unit, vstring& result) { - CALL("Parser::findAxiomName"); return _axiomNames.find(unit->number(), result); } // TPTP::findAxiomName @@ -5011,8 +4871,6 @@ bool TPTP::findAxiomName(const Unit* unit, vstring& result) */ void TPTP::vampire() { - CALL("TPTP::vampire"); - consumeToken(T_LPAR); vstring nm = name(); diff --git a/Parse/TPTP.hpp b/Parse/TPTP.hpp index f3da7895a..f42b0ed77 100644 --- a/Parse/TPTP.hpp +++ b/Parse/TPTP.hpp @@ -668,8 +668,6 @@ class TPTP */ inline char getChar(int pos) { - CALL("TPTP::getChar"); - while (_cend <= pos) { int c = _in->get(); // if (c == -1) { cout << ""; } else {cout << char(c);} @@ -683,7 +681,6 @@ class TPTP */ inline void shiftChars(int n) { - CALL("TPTP::shiftChars"); ASS(n > 0); ASS(n <= _cend); @@ -709,8 +706,6 @@ class TPTP */ inline Token& getTok(int pos) { - CALL("TPTP::getTok"); - while (_tend <= pos) { Token& tok = _tokens[_tend++]; readToken(tok); @@ -723,8 +718,6 @@ class TPTP */ inline void shiftToks(int n) { - CALL("TPTP::shiftToks"); - ASS(n > 0); ASS(n <= _tend); diff --git a/SAT/BufferedSolver.cpp b/SAT/BufferedSolver.cpp index a9b495386..2fb5d515c 100644 --- a/SAT/BufferedSolver.cpp +++ b/SAT/BufferedSolver.cpp @@ -24,7 +24,6 @@ namespace SAT BufferedSolver::BufferedSolver(SATSolver* inner) : _inner(inner), _checkedIdx(0), _lastStatus(SATISFIABLE), _varCnt(0), _varCntInnerOld(0) { - CALL("BufferedSolver::BufferedSolver"); } /** * Check if cl is implied by the current model i.e. if a literal @@ -39,8 +38,6 @@ BufferedSolver::BufferedSolver(SATSolver* inner) */ bool BufferedSolver::checkAndRecordImplied(SATClause* cl) { - CALL("BufferedSolver::checkAndRecordImplied"); - static SATLiteralStack newLiterals; newLiterals.reset(); @@ -79,8 +76,6 @@ bool BufferedSolver::checkAndRecordImplied(SATClause* cl) */ void BufferedSolver::addClause(SATClause* cl) { - CALL("BufferedSolver::addClause"); - _unadded.push(cl); } @@ -95,8 +90,6 @@ void BufferedSolver::addClause(SATClause* cl) */ void BufferedSolver::flushUnadded() { - CALL("BufferedSolver::flushUnadded"); - //update maxVar _varCntInnerOld=_varCnt; @@ -119,8 +112,6 @@ void BufferedSolver::flushUnadded() */ SATSolver::Status BufferedSolver::solve(unsigned conflictCountLimit) { - CALL("BufferedSolver::solve"); - // BufferedSolver does not support "UNKNOWN" status as // it needs _inner to have either a model or to be provably unsat ASS_EQ(conflictCountLimit, UINT_MAX); @@ -154,7 +145,6 @@ SATSolver::Status BufferedSolver::solve(unsigned conflictCountLimit) */ SATSolver::VarAssignment BufferedSolver::getAssignment(unsigned var) { - CALL("BufferedSolver::getAssignment"); ASS_G(var,0); ASS_LE(var,_varCnt); // check buffer diff --git a/SAT/BufferedSolver.hpp b/SAT/BufferedSolver.hpp index af6a77ae9..2cc414898 100644 --- a/SAT/BufferedSolver.hpp +++ b/SAT/BufferedSolver.hpp @@ -58,7 +58,6 @@ class BufferedSolver : public SATSolver { virtual VarAssignment getAssignment(unsigned var) override; virtual bool isZeroImplied(unsigned var) override { - CALL("BufferedSolver::isZeroImplied"); ASS_G(var,0); ASS_LE(var,_varCnt); // alternatively, we could directly refer to _inner, it must handle variables up to _varCnt as well return (var > _varCntInnerOld) ? false : _inner->isZeroImplied(var); @@ -68,8 +67,6 @@ class BufferedSolver : public SATSolver { virtual void ensureVarCount(unsigned newVarCnt) override { _inner->ensureVarCount(newVarCnt); _varCnt=max(_varCnt,newVarCnt); } virtual unsigned newVar() override { - CALL("BufferedSolver::newVar"); - ALWAYS(_inner->newVar() == ++_varCnt); return _varCnt; } diff --git a/SAT/FallbackSolverWrapper.cpp b/SAT/FallbackSolverWrapper.cpp index 05c76bf89..abe22a60a 100644 --- a/SAT/FallbackSolverWrapper.cpp +++ b/SAT/FallbackSolverWrapper.cpp @@ -27,7 +27,6 @@ namespace SAT FallbackSolverWrapper::FallbackSolverWrapper(SATSolver* inner,SATSolver* fallback) : _inner(inner), _fallback(fallback), _usingFallback(false), _varCnt(0) { - CALL("FallbackSolverWrapper::FallbackSolverWrapper"); } /** @@ -37,8 +36,6 @@ FallbackSolverWrapper::FallbackSolverWrapper(SATSolver* inner,SATSolver* fallbac */ void FallbackSolverWrapper::addClause(SATClause* cl) { - CALL("FallbackSolverWrapper::addClause"); - _inner->addClause(cl); _fallback->addClause(cl); } @@ -49,8 +46,6 @@ void FallbackSolverWrapper::addClause(SATClause* cl) */ SATSolver::Status FallbackSolverWrapper::solve(unsigned conflictCountLimit) { - CALL("FallbackSolverWrapper::solve"); - // Currently always run the _inner solver to see if we can use it Status status = _inner->solve(conflictCountLimit); @@ -73,7 +68,6 @@ SATSolver::Status FallbackSolverWrapper::solve(unsigned conflictCountLimit) */ SATSolver::VarAssignment FallbackSolverWrapper::getAssignment(unsigned var) { - CALL("FallbackSolverWrapper::getAssignment"); ASS_G(var,0); ASS_LE(var,_varCnt); if(_usingFallback){ diff --git a/SAT/FallbackSolverWrapper.hpp b/SAT/FallbackSolverWrapper.hpp index 68c768082..008e29e36 100644 --- a/SAT/FallbackSolverWrapper.hpp +++ b/SAT/FallbackSolverWrapper.hpp @@ -64,7 +64,6 @@ class FallbackSolverWrapper : public SATSolver { virtual VarAssignment getAssignment(unsigned var) override; virtual bool isZeroImplied(unsigned var) override { - CALL("FallbackSolverWrapper::isZeroImplied"); ASS_G(var,0); ASS_LE(var,_varCnt); if(_usingFallback){ @@ -97,8 +96,6 @@ class FallbackSolverWrapper : public SATSolver { virtual unsigned newVar() override { - CALL("FallbackSolverWrapper::newVar"); - ALWAYS(_inner->newVar() == ++_varCnt); ALWAYS(_fallback->newVar() == _varCnt); return _varCnt; diff --git a/SAT/MinimizingSolver.cpp b/SAT/MinimizingSolver.cpp index 98531dfc7..cfea051e0 100644 --- a/SAT/MinimizingSolver.cpp +++ b/SAT/MinimizingSolver.cpp @@ -22,13 +22,10 @@ namespace SAT MinimizingSolver::MinimizingSolver(SATSolver* inner) : _varCnt(0), _inner(inner), _assignmentValid(false), _heap(CntComparator(_unsClCnt)) { - CALL("MinimizingSolver::MinimizingSolver"); } void MinimizingSolver::ensureVarCount(unsigned newVarCnt) { - CALL("MinimizingSolver::ensureVarCount"); - if (newVarCnt<= _varCnt) { return; } @@ -44,8 +41,6 @@ void MinimizingSolver::ensureVarCount(unsigned newVarCnt) void MinimizingSolver::addClause(SATClause* cl) { - CALL("MinimizingSolver::addClause"); - // pass it to inner ... _inner->addClause(cl); _assignmentValid = false; @@ -62,8 +57,6 @@ void MinimizingSolver::addClause(SATClause* cl) void MinimizingSolver::addClauseIgnoredInPartialModel(SATClause* cl) { - CALL("MinimizingSolver::addClauseIgnoredInPartialModel"); - // just passing to _inner, but for minimization it will be ignored _inner->addClause(cl); _assignmentValid = false; @@ -71,14 +64,12 @@ void MinimizingSolver::addClauseIgnoredInPartialModel(SATClause* cl) SATSolver::Status MinimizingSolver::solve(unsigned conflictCountLimit) { - CALL("MinimizingSolver::solve"); _assignmentValid = false; return _inner->solve(conflictCountLimit); } SATSolver::VarAssignment MinimizingSolver::getAssignment(unsigned var) { - CALL("MinimizingSolver::getAssignment"); ASS_G(var,0); ASS_LE(var,_varCnt); if(!_assignmentValid) { @@ -93,7 +84,6 @@ SATSolver::VarAssignment MinimizingSolver::getAssignment(unsigned var) bool MinimizingSolver::isZeroImplied(unsigned var) { - CALL("MinimizingSolver::isZeroImplied"); ASS_G(var,0); ASS_LE(var,_varCnt); bool res = _inner->isZeroImplied(var); @@ -106,7 +96,6 @@ bool MinimizingSolver::isZeroImplied(unsigned var) */ void MinimizingSolver::selectVariable(unsigned var) { - CALL("MinimizingSolver::selectVariable"); ASS_G(var,0); ASS_LE(var,_varCnt); ASS_G(_unsClCnt[var],0); @@ -135,8 +124,6 @@ void MinimizingSolver::selectVariable(unsigned var) void MinimizingSolver::putIntoIndex(SATClause* cl) { - CALL("MinimizingSolver::putIntoIndex"); - SATClause::Iterator cit(*cl); while(cit.hasNext()) { SATLiteral lit = cit.next(); @@ -151,8 +138,6 @@ void MinimizingSolver::putIntoIndex(SATClause* cl) bool MinimizingSolver::tryPuttingToAnExistingWatch(SATClause* cl) { - CALL("MinimizingSolver::tryPuttingToAnExistingWatch"); - SATClause::Iterator cit(*cl); while(cit.hasNext()) { SATLiteral lit = cit.next(); @@ -172,8 +157,6 @@ bool MinimizingSolver::tryPuttingToAnExistingWatch(SATClause* cl) */ void MinimizingSolver::processUnprocessedAndFillHeap() { - CALL("MinimizingSolver::processUnprocessed"); - while(_unprocessed.isNonEmpty()) { SATClause* cl = _unprocessed.pop(); ASS_G(cl->length(),0) @@ -197,8 +180,6 @@ void MinimizingSolver::processUnprocessedAndFillHeap() */ void MinimizingSolver::processInnerAssignmentChanges() { - CALL("MinimizingSolver::processInnerAssignmentChanges"); - for(unsigned v=1; v<=_varCnt; v++) { VarAssignment va = _inner->getAssignment(v); bool changed; @@ -231,8 +212,6 @@ void MinimizingSolver::processInnerAssignmentChanges() void MinimizingSolver::updateAssignment() { - CALL("MinimizingSolver::updateAssignment"); - TIME_TRACE("minimizing solver time"); processInnerAssignmentChanges(); diff --git a/SAT/MinimizingSolver.hpp b/SAT/MinimizingSolver.hpp index 3798e2f95..fe732aedb 100644 --- a/SAT/MinimizingSolver.hpp +++ b/SAT/MinimizingSolver.hpp @@ -61,7 +61,6 @@ class MinimizingSolver : public SATSolver { virtual void ensureVarCount(unsigned newVarCnt) override; virtual unsigned newVar() override { - CALL("MinimizingSolver::newVar"); DEBUG_CODE(unsigned oldVC = _varCnt); ensureVarCount(_varCnt+1); ASS_EQ(_varCnt,oldVC+1); @@ -72,7 +71,6 @@ class MinimizingSolver : public SATSolver { private: bool admitsDontcare(unsigned var) { - CALL("MinimizingSolver::admitsDontcare"); ASS_G(var,0); ASS_LE(var,_varCnt); return _watcher[var].isEmpty() && !_inner->isZeroImplied(var); diff --git a/SAT/MinisatInterfacing.cpp b/SAT/MinisatInterfacing.cpp index b9aaa3c3e..ca1dd9226 100644 --- a/SAT/MinisatInterfacing.cpp +++ b/SAT/MinisatInterfacing.cpp @@ -29,8 +29,6 @@ using namespace Minisat; MinisatInterfacing::MinisatInterfacing(const Shell::Options& opts, bool generateProofs): _status(SATISFIABLE) { - CALL("MinisatInterfacing::MinisatInterfacing"); - // TODO: consider tuning minisat's options to be set for _solver // (or even forwarding them to vampire's options) } @@ -41,8 +39,6 @@ MinisatInterfacing::MinisatInterfacing(const Shell::Options& opts, bool generate */ void MinisatInterfacing::ensureVarCount(unsigned newVarCnt) { - CALL("MinisatInterfacing::ensureVarCount"); - while(_solver.nVars() < (int)newVarCnt) { _solver.newVar(); } @@ -50,15 +46,11 @@ void MinisatInterfacing::ensureVarCount(unsigned newVarCnt) unsigned MinisatInterfacing::newVar() { - CALL("MinisatInterfacing::newVar"); - return minisatVar2Vampire(_solver.newVar()); } SATSolver::Status MinisatInterfacing::solveUnderAssumptions(const SATLiteralStack& assumps, unsigned conflictCountLimit, bool) { - CALL("MinisatInterfacing::solveUnderAssumptions"); - ASS(!hasAssumptions()); // load assumptions: @@ -89,8 +81,6 @@ SATSolver::Status MinisatInterfacing::solveUnderAssumptions(const SATLiteralStac */ void MinisatInterfacing::solveModuloAssumptionsAndSetStatus(unsigned conflictCountLimit) { - CALL("MinisatInterfacing::solveModuloAssumptionsAndSetStatus"); - // TODO: consider calling simplify(); or only from time to time? _solver.setConfBudget(conflictCountLimit); // treating UINT_MAX as \infty @@ -111,8 +101,6 @@ void MinisatInterfacing::solveModuloAssumptionsAndSetStatus(unsigned conflictCou */ void MinisatInterfacing::addClause(SATClause* cl) { - CALL("MinisatInterfacing::addClause"); - // store to later generate the refutation PrimitiveProofRecordingSATSolver::addClause(cl); @@ -137,22 +125,17 @@ void MinisatInterfacing::addClause(SATClause* cl) */ SATSolver::Status MinisatInterfacing::solve(unsigned conflictCountLimit) { - CALL("MinisatInterfacing::solve"); - solveModuloAssumptionsAndSetStatus(conflictCountLimit); return _status; } void MinisatInterfacing::addAssumption(SATLiteral lit) { - CALL("MinisatInterfacing::addAssumption"); - _assumptions.push(vampireLit2Minisat(lit)); } SATSolver::VarAssignment MinisatInterfacing::getAssignment(unsigned var) { - CALL("MinisatInterfacing::getAssignment"); ASS_EQ(_status, SATISFIABLE); ASS_G(var,0); ASS_LE(var,(unsigned)_solver.nVars()); lbool res; @@ -174,7 +157,6 @@ SATSolver::VarAssignment MinisatInterfacing::getAssignment(unsigned var) bool MinisatInterfacing::isZeroImplied(unsigned var) { - CALL("MinisatInterfacing::isZeroImplied"); ASS_G(var,0); ASS_LE(var,(unsigned)_solver.nVars()); /* between calls to _solver.solve* @@ -184,8 +166,6 @@ bool MinisatInterfacing::isZeroImplied(unsigned var) void MinisatInterfacing::collectZeroImplied(SATLiteralStack& acc) { - CALL("MinisatInterfacing::collectZeroImplied"); - // TODO: could be made more efficient by inspecting the trail // [new code would be needed in Minisat::solver, though] @@ -202,8 +182,6 @@ void MinisatInterfacing::collectZeroImplied(SATLiteralStack& acc) SATClause* MinisatInterfacing::getZeroImpliedCertificate(unsigned) { - CALL("MinisatInterfacing::getZeroImpliedCertificate"); - // Currently unused anyway. /* The whole SATSolver interface should be revised before @@ -214,8 +192,6 @@ SATClause* MinisatInterfacing::getZeroImpliedCertificate(unsigned) SATClauseList* MinisatInterfacing::minimizePremiseList(SATClauseList* premises, SATLiteralStack& assumps) { - CALL("MinisatInterfacing::minimizePremiseList"); - Minisat::Solver solver; static DHMap var2prem; @@ -312,8 +288,6 @@ SATClauseList* MinisatInterfacing::minimizePremiseList(SATClauseList* premises, void MinisatInterfacing::interpolateViaAssumptions(unsigned maxVar, const SATClauseStack& first, const SATClauseStack& second, SATClauseStack& result) { - CALL("MinisatInterfacing::interpolateViaAssumptions"); - Minisat::Solver solver_first; Minisat::Solver solver_second; diff --git a/SAT/MinisatInterfacing.hpp b/SAT/MinisatInterfacing.hpp index a1492b361..98ca9ab77 100644 --- a/SAT/MinisatInterfacing.hpp +++ b/SAT/MinisatInterfacing.hpp @@ -43,7 +43,6 @@ class MinisatInterfacing : public PrimitiveProofRecordingSATSolver * (Minisat deletes unconditionally satisfied clauses.) */ virtual void simplify() override { - CALL("MinisatInterfacing::simplify"); _solver.simplify(); } diff --git a/SAT/MinisatInterfacingNewSimp.cpp b/SAT/MinisatInterfacingNewSimp.cpp index f19f7b7c6..e46788739 100644 --- a/SAT/MinisatInterfacingNewSimp.cpp +++ b/SAT/MinisatInterfacingNewSimp.cpp @@ -38,8 +38,6 @@ const unsigned MinisatInterfacingNewSimp::VAR_MAX = std::numeric_limitsisPositive(); Literal* posLit = Literal::positiveLiteral(l); unsigned var = _posMap.get(posLit); @@ -48,8 +45,6 @@ SATLiteral SAT2FO::toSAT(Literal* l) */ Literal* SAT2FO::toFO(SATLiteral sl) const { - CALL("SAT2FO::toFO"); - Literal* posLit; if(!_posMap.findObj(sl.var(), posLit)) { return 0; @@ -66,8 +61,6 @@ Literal* SAT2FO::toFO(SATLiteral sl) const */ SATClause* SAT2FO::toSAT(Clause* cl) { - CALL("SAT2FO::toSAT"); - Clause::Iterator cit(*cl); static SATLiteralStack satLits; @@ -89,7 +82,6 @@ SATClause* SAT2FO::toSAT(Clause* cl) void SAT2FO::collectAssignment(SATSolver& solver, LiteralStack& res) const { - CALL("SAT2FO::collectAssignment"); // ASS_EQ(solver.getStatus(), SATSolver::SATISFIABLE); ASS(res.isEmpty()); @@ -114,8 +106,6 @@ void SAT2FO::collectAssignment(SATSolver& solver, LiteralStack& res) const SATClause* SAT2FO::createConflictClause(LiteralStack& unsatCore, InferenceRule rule) { - CALL("SAT2FO::createConflictClause"); - static LiteralStack negStack; negStack.reset(); LiteralStack::ConstIterator ucit(unsatCore); diff --git a/SAT/SATClause.cpp b/SAT/SATClause.cpp index 6a2215af9..1afc4cf66 100644 --- a/SAT/SATClause.cpp +++ b/SAT/SATClause.cpp @@ -42,8 +42,6 @@ using namespace Shell; */ void* SATClause::operator new(size_t sz,unsigned lits) { - CALL("SATClause::operator new"); - //We have to get sizeof(SATClause) + (_length-1)*sizeof(SATLiteral*) //this way, because _length-1 wouldn't behave well for //_length==0 on x64 platform. @@ -82,8 +80,6 @@ SATClause::SATClause(unsigned length) */ void SATClause::destroy() { - CALL("SATClause::destroy"); - if(_nonDestroyable) { //we don't destroy non-destroyable clauses. //This is to protect clauses which may act as premises to other clauses. @@ -114,7 +110,6 @@ void SATClause::destroy() void SATClause::setInference(SATInference* val) { - CALL("SATClause::setInference"); ASS(!_inference); _inference = val; @@ -144,8 +139,6 @@ void SATClause::sort() SATClause* SATClause::removeDuplicateLiterals(SATClause* cl) { - CALL("SATClause::removeDuplicateLiterals(SATClause*)"); - unsigned clen=cl->length(); cl->sort(); @@ -189,8 +182,6 @@ SATClause* SATClause::removeDuplicateLiterals(SATClause* cl) SATClause* SATClause::fromStack(SATLiteralStack& stack) { - CALL("SATClause::fromStack"); - unsigned clen = stack.size(); SATClause* rcl=new(clen) SATClause(clen); @@ -210,8 +201,6 @@ SATClause* SATClause::fromStack(SATLiteralStack& stack) */ vstring SATClause::toString() const { - CALL("SATClause::toString"); - vstring result; if (_length == 0) { result = "#"; diff --git a/SAT/SATInference.cpp b/SAT/SATInference.cpp index fdc3642ec..0e2c06d3e 100644 --- a/SAT/SATInference.cpp +++ b/SAT/SATInference.cpp @@ -31,15 +31,12 @@ namespace SAT */ void SATInference::collectFOPremises(SATClause* cl, Stack& acc) { - CALL("SATInference::collectFOPremises"); - collectFilteredFOPremises(cl,acc, [](SATClause*) {return true; } ); } UnitList* SATInference::getFOPremises(SATClause* cl) { - CALL("SATInference::getFOPremises"); ASS(cl); ASS(cl->inference()); @@ -59,8 +56,6 @@ UnitList* SATInference::getFOPremises(SATClause* cl) void SATInference::collectPropAxioms(SATClause* cl, SATClauseStack& res) { - CALL("SATInference::collectPropAxioms"); - static Stack toDo; static DHSet seen; toDo.reset(); @@ -107,7 +102,6 @@ FOConversionInference::FOConversionInference(Clause* cl) : _origin(cl) } FOConversionInference::~FOConversionInference() { - CALL("FOConversionInference::~FOConversionInference"); _origin->decRefCnt(); } diff --git a/SAT/SATInference.hpp b/SAT/SATInference.hpp index a9b8b547e..0dc0cb773 100644 --- a/SAT/SATInference.hpp +++ b/SAT/SATInference.hpp @@ -140,7 +140,6 @@ class AssumptionInference : public SATInference template void SATInference::collectFilteredFOPremises(SATClause* cl, Stack& acc, Filter f) { - CALL("SATInference::collectFilteredFOPremises"); ASS_ALLOC_TYPE(cl, "SATClause"); static Stack toDo; diff --git a/SAT/SATSolver.hpp b/SAT/SATSolver.hpp index 6efc905ab..4b381be0b 100644 --- a/SAT/SATSolver.hpp +++ b/SAT/SATSolver.hpp @@ -52,7 +52,6 @@ class SATSolver { virtual void addClause(SATClause* cl) = 0; void addClausesIter(SATClauseIterator cit) { - CALL("SATSolver::addClauses"); while (cit.hasNext()) { addClause(cit.next()); } @@ -140,7 +139,6 @@ class SATSolver { * a different model (provided the status will be satisfiable). */ virtual void randomizeForNextAssignment(unsigned maxVar) { - CALL("SATSolver::randomizeForNextAssignment"); for (unsigned var=1; var <= maxVar; var++) { suggestPolarity(var,Random::getBit()); } @@ -171,8 +169,6 @@ class SATSolver { */ bool trueInAssignment(SATLiteral lit) { - CALL("SATSolver::trueInAssignment"); - VarAssignment asgn = getAssignment(lit.var()); VarAssignment desired = lit.polarity() ? TRUE : FALSE; return asgn==desired; @@ -183,8 +179,6 @@ class SATSolver { */ bool falseInAssignment(SATLiteral lit) { - CALL("SATSolver::trueInAssignment"); - VarAssignment asgn = getAssignment(lit.var()); VarAssignment desired = lit.polarity() ? FALSE: TRUE; return asgn==desired; @@ -240,8 +234,6 @@ class SATSolverWithAssumptions: // to clean in the end. virtual Status solveUnderAssumptions(const SATLiteralStack& assumps, unsigned conflictCountLimit, bool onlyProperSubusets) { - CALL("SATSolver::solveUnderAssumptions"); - ASS(!hasAssumptions()); _failedAssumptionBuffer.reset(); @@ -302,8 +294,6 @@ class SATSolverWithAssumptions: } virtual const SATLiteralStack& explicitlyMinimizedFailedAssumptions(unsigned conflictCountLimit, bool randomize) { - CALL("SATSolver::explicitlyMinimizeFailedAssumptions"); - // assumes solveUnderAssumptions(...,conflictCountLimit,...) just returned UNSAT and initialized _failedAssumptionBuffer ASS(!hasAssumptions()); @@ -364,29 +354,21 @@ class PrimitiveProofRecordingSATSolver : public SATSolverWithAssumptions { PrimitiveProofRecordingSATSolver() : _addedClauses(0), _refutation(new(0) SATClause(0)), _refutationInference(new PropInference(SATClauseList::empty())) { - CALL("PrimitiveProofRecordingSATSolver::PrimitiveProofRecordingSATSolver"); - _refutation->setInference(_refutationInference); } virtual ~PrimitiveProofRecordingSATSolver() { - CALL("PrimitiveProofRecordingSATSolver::~PrimitiveProofRecordingSATSolver"); - // cannot clear the list - some inferences may be keeping its suffices till proof printing phase ... // _addedClauses->destroy(); // we clear the list but not its content } virtual void addClause(SATClause* cl) override { - CALL("PrimitiveProofRecordingSATSolver::addClause"); - SATClauseList::push(cl,_addedClauses); } virtual SATClause* getRefutation() override { - CALL("PrimitiveProofRecordingSATSolver::getRefutation"); - // connect the added clauses ... SATClauseList* prems = _addedClauses; diff --git a/SAT/Z3Interfacing.cpp b/SAT/Z3Interfacing.cpp index 36433b580..61e453887 100644 --- a/SAT/Z3Interfacing.cpp +++ b/SAT/Z3Interfacing.cpp @@ -124,7 +124,6 @@ Z3Interfacing::Z3Interfacing(SAT2FO& s2f, bool showZ3, bool unsatCoresForAssumpt _unsatCore(unsatCoresForAssumptions), _out() { - CALL("Z3Interfacing::Z3Interfacing"); BYPASSING_ALLOCATOR _out = exportSmtlib == "" ? Option() : Option(std::ofstream(exportSmtlib.c_str())) ; @@ -161,14 +160,11 @@ Z3Interfacing::Z3Interfacing(SAT2FO& s2f, bool showZ3, bool unsatCoresForAssumpt char const* Z3Interfacing::z3_full_version() { - CALL("Z3Interfacing::z3_version"); return Z3_get_full_version(); } unsigned Z3Interfacing::newVar() { - CALL("Z3Interfacing::newVar"); - ++_varCnt; // to make sure all the literals we will ask about later have allocated counterparts internally @@ -179,7 +175,6 @@ unsigned Z3Interfacing::newVar() void Z3Interfacing::addClause(SATClause* cl) { - CALL("Z3Interfacing::addClause"); BYPASSING_ALLOCATOR; ASS(cl); @@ -216,8 +211,6 @@ void Z3Interfacing::retractAllAssumptions() void Z3Interfacing::addAssumption(SATLiteral lit) { - CALL("Z3Interfacing::addAssumption"); - auto pushAssumption = [&](SATLiteral lit) -> z3::expr { auto repr = getRepresentation(lit); @@ -257,7 +250,6 @@ Z3Interfacing::Representation Z3Interfacing::getRepresentation(SATClause* cl) SATSolver::Status Z3Interfacing::solve() { - CALL("Z3Interfacing::solve()"); BYPASSING_ALLOCATOR; DEBUG("assumptions: ", _assumptions); @@ -320,8 +312,6 @@ SATSolver::Status Z3Interfacing::solve() SATSolver::Status Z3Interfacing::solveUnderAssumptions(const SATLiteralStack& assumps, unsigned conflictCountLimit, bool onlyProperSubusets) { - CALL("Z3Interfacing::solveUnderAssumptions"); - if (!_unsatCore) { return SATSolverWithAssumptions::solveUnderAssumptions(assumps,conflictCountLimit,onlyProperSubusets); } @@ -338,7 +328,6 @@ SATSolver::Status Z3Interfacing::solveUnderAssumptions(const SATLiteralStack& as SATSolver::VarAssignment Z3Interfacing::getAssignment(unsigned var) { - CALL("Z3Interfacing::getAssignment"); BYPASSING_ALLOCATOR; ASS_EQ(_status,SATISFIABLE); @@ -404,7 +393,6 @@ struct EvaluateInModel Result operator()(z3::expr expr, Result* evaluatedArgs) { - CALL("EvaluateInModel::operator()") DEBUG("in: ", expr) auto intVal = [](z3::expr e) -> Option { int val; @@ -464,7 +452,6 @@ struct EvaluateInModel Term* Z3Interfacing::evaluateInModel(Term* trm) { - CALL("evaluateInModel(Term*)") DEBUG("in: ", *trm) DEBUG("model: \n", _model) ASS(!trm->isLiteral()); @@ -500,21 +487,17 @@ Term* Z3Interfacing::evaluateInModel(Term* trm) bool Z3Interfacing::isZeroImplied(unsigned var) { - CALL("Z3Interfacing::isZeroImplied"); - // Safe. TODO consider getting zero-implied return false; } void Z3Interfacing::collectZeroImplied(SATLiteralStack& acc) { - CALL("Z3Interfacing::collectZeroImplied"); NOT_IMPLEMENTED; } SATClause* Z3Interfacing::getZeroImpliedCertificate(unsigned) { - CALL("Z3Interfacing::getZeroImpliedCertificate"); NOT_IMPLEMENTED; return 0; @@ -522,8 +505,6 @@ SATClause* Z3Interfacing::getZeroImpliedCertificate(unsigned) z3::sort Z3Interfacing::getz3sort(SortId s) { - CALL("Z3Interfacing::getz3sort"); - BYPASSING_ALLOCATOR; auto srt = _sorts.tryGet(s); if (srt.isSome()) { @@ -568,7 +549,6 @@ vstring to_vstring(A const& a) void Z3Interfacing::createTermAlgebra(TermList sort) { - CALL("createTermAlgebra(TermList)") ASS(sort.isTerm() && sort.term()->isSort()); if (_createdTermAlgebras.contains(sort)) return; @@ -781,7 +761,6 @@ void Z3Interfacing::createTermAlgebra(TermList sort) z3::func_decl const& Z3Interfacing::findConstructor(Term* t) { - CALL("Z3Interfacing::findConstructor(FuncId id)") auto id = FuncOrPredId::monomorphicFunction(t->functor()); auto f = _toZ3.tryGet(id); if (f.isSome()) { @@ -847,7 +826,6 @@ struct ToZ3Expr z3::expr operator()(TermList toEval, z3::expr* args) { - CALL("ToZ3Expr::operator()"); // DEBUG("in: ", toEval) ASS(toEval.isTerm()) auto trm = toEval.term(); @@ -1086,7 +1064,6 @@ struct ToZ3Expr z3::func_decl Z3Interfacing::z3Function(FuncOrPredId functor) { - CALL("Z3Interfacing::z3Function"); auto& self = *this; auto found = self._toZ3.tryGet(functor); @@ -1133,7 +1110,6 @@ z3::func_decl Z3Interfacing::z3Function(FuncOrPredId functor) */ Z3Interfacing::Representation Z3Interfacing::getRepresentation(Term* trm) { - CALL("Z3Interfacing::getRepresentation(Term*)"); Stack defs; auto expr = evaluateBottomUp(TermList(trm), ToZ3Expr{ *this, defs }); return Representation(expr, std::move(defs)); @@ -1141,7 +1117,6 @@ Z3Interfacing::Representation Z3Interfacing::getRepresentation(Term* trm) Z3Interfacing::Representation Z3Interfacing::getRepresentation(SATLiteral slit) { - CALL("Z3Interfacing::getRepresentation(SATLiteral)"); BYPASSING_ALLOCATOR; @@ -1187,8 +1162,6 @@ Z3Interfacing::Representation Z3Interfacing::getRepresentation(SATLiteral slit) SATClause* Z3Interfacing::getRefutation() { - CALL("Z3Interfacing::getRefutation"); - return PrimitiveProofRecordingSATSolver::getRefutation(); // TODO: optionally, we could try getting an unsat core from Z3 (could be smaller than all the added clauses so far) @@ -1198,7 +1171,6 @@ SATClause* Z3Interfacing::getRefutation() Z3Interfacing::~Z3Interfacing() { - CALL("~Z3Interfacing") _sorts.clear(); _toZ3.clear(); _fromZ3.clear(); diff --git a/SAT/Z3Interfacing.hpp b/SAT/Z3Interfacing.hpp index 75cb93bc3..2ccd1f311 100644 --- a/SAT/Z3Interfacing.hpp +++ b/SAT/Z3Interfacing.hpp @@ -50,7 +50,6 @@ namespace SAT{ { UninterpretedForZ3Exception() { - CALL("Z3Interfacing::UninterpretedForZ3Exception::UninterpretedForZ3Exception"); } }; @@ -98,8 +97,6 @@ class Z3Interfacing : public PrimitiveProofRecordingSATSolver virtual SATClause* getZeroImpliedCertificate(unsigned var) override; void ensureVarCount(unsigned newVarCnt) override { - CALL("Z3Interfacing::ensureVarCnt"); - while (_varCnt < newVarCnt) { newVar(); } diff --git a/SAT/Z3MainLoop.cpp b/SAT/Z3MainLoop.cpp index 9edd328e5..1f5de4ad8 100644 --- a/SAT/Z3MainLoop.cpp +++ b/SAT/Z3MainLoop.cpp @@ -29,21 +29,14 @@ using namespace Lib; Z3MainLoop::Z3MainLoop(Problem& prb, const Options& opt) : MainLoop(prb,opt) { - CALL("Z3MainLoop::Z3MainLoop"); - } void Z3MainLoop::init() { - CALL("Z3MainLoop::init"); - - } MainLoopResult Z3MainLoop::runImpl() { - CALL("Z3MainLoop::runImpl"); - if(!_prb.getProperty()->allNonTheoryClausesGround()){ return MainLoopResult(Statistics::INAPPROPRIATE); } diff --git a/Saturation/AWPassiveClauseContainer.cpp b/Saturation/AWPassiveClauseContainer.cpp index 66c011f8c..6e1f3b463 100644 --- a/Saturation/AWPassiveClauseContainer.cpp +++ b/Saturation/AWPassiveClauseContainer.cpp @@ -62,8 +62,6 @@ AWPassiveClauseContainer::AWPassiveClauseContainer(bool isOutermost, const Shell _weightSelectionMaxWeight(UINT_MAX), _weightSelectionMaxAge(UINT_MAX) { - CALL("AWPassiveClauseContainer::AWPassiveClauseContainer"); - if(_opt.ageWeightRatioShape() == Options::AgeWeightRatioShape::CONVERGE) { _ageRatio = 1; _weightRatio = 1; @@ -95,8 +93,6 @@ AWPassiveClauseContainer::~AWPassiveClauseContainer() */ Comparison AWPassiveClauseContainer::compareWeight(Clause* cl1, Clause* cl2, const Options& opt) { - CALL("AWPassiveClauseContainer::compareWeight"); - return Int::compare(cl1->weightForClauseSelection(opt), cl2->weightForClauseSelection(opt)); } @@ -112,8 +108,6 @@ Comparison AWPassiveClauseContainer::compareWeight(Clause* cl1, Clause* cl2, con */ bool WeightQueue::lessThan(Clause* c1,Clause* c2) { - CALL("WeightQueue::lessThan"); - if(env.options->prioritiseClausesProducedByLongReduction()){ if(c1->inference().reductions() < c2->inference().reductions()){ return false; @@ -157,8 +151,6 @@ bool WeightQueue::lessThan(Clause* c1,Clause* c2) */ bool AgeQueue::lessThan(Clause* c1,Clause* c2) { - CALL("AgeQueue::lessThan"); - if (c1->age() < c2->age()) { return true; } @@ -187,7 +179,6 @@ bool AgeQueue::lessThan(Clause* c1,Clause* c2) */ void AWPassiveClauseContainer::add(Clause* cl) { - CALL("AWPassiveClauseContainer::add"); ASS(_ageRatio > 0 || _weightRatio > 0); ASS(cl->store() == Clause::PASSIVE); @@ -213,7 +204,6 @@ void AWPassiveClauseContainer::add(Clause* cl) */ void AWPassiveClauseContainer::remove(Clause* cl) { - CALL("AWPassiveClauseContainer::remove"); if (_isOutermost) { ASS(cl->store()==Clause::PASSIVE); @@ -240,8 +230,6 @@ void AWPassiveClauseContainer::remove(Clause* cl) bool AWPassiveClauseContainer::byWeight(int balance) { - CALL("AWPassiveClauseContainer::byWeight"); - if (! _ageRatio) { return true; } @@ -265,7 +253,6 @@ bool AWPassiveClauseContainer::byWeight(int balance) */ Clause* AWPassiveClauseContainer::popSelected() { - CALL("AWPassiveClauseContainer::popSelected"); ASS( ! isEmpty()); auto shape = _opt.ageWeightRatioShape(); @@ -322,8 +309,6 @@ Clause* AWPassiveClauseContainer::popSelected() void AWPassiveClauseContainer::onLimitsUpdated() { - CALL("AWPassiveClauseContainer::onLimitsUpdated"); - if ( (_ageRatio > 0 && !ageLimited()) || (_weightRatio > 0 && !weightLimited()) ) { return; @@ -361,7 +346,6 @@ void AWPassiveClauseContainer::onLimitsUpdated() void AWPassiveClauseContainer::simulationInit() { - CALL("AWPassiveClauseContainer::simulationInit"); _simulationBalance = _balance; // initialize iterators @@ -392,8 +376,6 @@ void AWPassiveClauseContainer::simulationInit() bool AWPassiveClauseContainer::simulationHasNext() { - CALL("AWPassiveClauseContainer::simulationHasNext"); - // Part 1: Return false if aw-container is empty if (_ageRatio == 0) { @@ -474,8 +456,6 @@ bool AWPassiveClauseContainer::simulationHasNext() // so each iterator (if used) does point to a clause which is not deleted in the simulation void AWPassiveClauseContainer::simulationPopSelected() { - CALL("AWPassiveClauseContainer::simulationPopSelected"); - // invariants: // - both queues share the aux-field which denotes whether a clause was deleted during the simulation // - if _ageRatio > 0 and _weightRatio > 0, then both queues contain the same clauses @@ -495,14 +475,11 @@ void AWPassiveClauseContainer::simulationPopSelected() bool AWPassiveClauseContainer::setLimitsToMax() { - CALL("AWPassiveClauseContainer::setLimitsToMax"); return setLimits(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX); } bool AWPassiveClauseContainer::setLimitsFromSimulation() { - CALL("AWPassiveClauseContainer::setLimitsFromSimulation"); - if (_ageRatio == 0) { if (_simulationCurrWeightCl == nullptr) @@ -603,7 +580,6 @@ bool AWPassiveClauseContainer::setLimitsFromSimulation() bool AWPassiveClauseContainer::childrenPotentiallyFulfilLimits(Clause* cl, unsigned upperBoundNumSelLits) const { - CALL("AWPassiveClauseContainer::childrenPotentiallyFulfilLimits"); if (cl->age() == _ageSelectionMaxAge) { // creating a fake inference to represent our current (pessimistic) estimate potential @@ -631,8 +607,6 @@ bool AWPassiveClauseContainer::childrenPotentiallyFulfilLimits(Clause* cl, unsig bool AWPassiveClauseContainer::setLimits(unsigned newAgeSelectionMaxAge, unsigned newAgeSelectionMaxWeight, unsigned newWeightSelectionMaxWeight, unsigned newWeightSelectionMaxAge) { - CALL("AWPassiveClauseContainer::setLimits"); - bool atLeastOneTightened = false; if(newAgeSelectionMaxAge != _ageSelectionMaxAge || newAgeSelectionMaxWeight != _ageSelectionMaxWeight) { if(newAgeSelectionMaxAge < _ageSelectionMaxAge) { @@ -657,21 +631,16 @@ bool AWPassiveClauseContainer::setLimits(unsigned newAgeSelectionMaxAge, unsigne bool AWPassiveClauseContainer::ageLimited() const { - CALL("AWPassiveClauseContainer::ageLimited"); - return _ageRatio > 0 && _ageSelectionMaxAge != UINT_MAX && _ageSelectionMaxWeight != UINT_MAX; } bool AWPassiveClauseContainer::weightLimited() const { - CALL("AWPassiveClauseContainer::weightLimited"); return _weightRatio > 0 && _weightSelectionMaxWeight != UINT_MAX && _weightSelectionMaxAge != UINT_MAX; } bool AWPassiveClauseContainer::fulfilsAgeLimit(Clause* cl) const { - CALL("AWPassiveClauseContainer::fulfilsAgeLimit(Clause*)"); - // don't want to reuse fulfilsAgeLimit(unsigned age,..) here, since we don't want to recompute weightForClauseSelection unsigned age = cl->age(); unsigned weightForClauseSelection = cl->weightForClauseSelection(_opt); @@ -680,8 +649,6 @@ bool AWPassiveClauseContainer::fulfilsAgeLimit(Clause* cl) const bool AWPassiveClauseContainer::fulfilsAgeLimit(unsigned w, unsigned numPositiveLiterals, const Inference& inference) const { - CALL("AWPassiveClauseContainer::fulfilsAgeLimit(unsigned, unsigned, const Inference&)"); - const unsigned age = inference.age(); const unsigned numeralWeight = 0; // heuristic: we don't want to compute the numeral weight during estimates and conservatively assume that it is 0. const unsigned splitWeight = 0; // also conservatively assuming 0 @@ -697,8 +664,6 @@ bool AWPassiveClauseContainer::fulfilsAgeLimit(unsigned w, unsigned numPositiveL bool AWPassiveClauseContainer::fulfilsWeightLimit(Clause* cl) const { - CALL("AWPassiveClauseContainer::fulfilsWeightLimit(Clause*)"); - // don't want to reuse fulfilsWeightLimit(unsigned w,..) here, since we don't want to recompute weightForClauseSelection unsigned weightForClauseSelection = cl->weightForClauseSelection(_opt); unsigned age = cl->age(); @@ -707,8 +672,6 @@ bool AWPassiveClauseContainer::fulfilsWeightLimit(Clause* cl) const bool AWPassiveClauseContainer::fulfilsWeightLimit(unsigned w, unsigned numPositiveLiterals, const Inference& inference) const { - CALL("AWPassiveClauseContainer::fulfilsWeightLimit(unsigned, unsigned, const Inference&)"); - const unsigned age = inference.age(); const unsigned numeralWeight = 0; // heuristic: we don't want to compute the numeral weight during estimates and conservatively assume that it is 0. const unsigned splitWeight = 0; // also conservatively assuming 0 @@ -729,8 +692,6 @@ AWClauseContainer::AWClauseContainer(const Options& opt) bool AWClauseContainer::isEmpty() const { - CALL("AWClauseContainer::isEmpty"); - ASS(!_ageRatio || !_weightRatio || _ageQueue.isEmpty()==_weightQueue.isEmpty()); return _ageQueue.isEmpty() && _weightQueue.isEmpty(); } @@ -741,7 +702,6 @@ bool AWClauseContainer::isEmpty() const */ void AWClauseContainer::add(Clause* cl) { - CALL("AWClauseContainer::add"); ASS(_ageRatio > 0 || _weightRatio > 0); if (_ageRatio) { @@ -759,8 +719,6 @@ void AWClauseContainer::add(Clause* cl) */ bool AWClauseContainer::remove(Clause* cl) { - CALL("AWClauseContainer::remove"); - bool removed; if (_ageRatio) { removed = _ageQueue.remove(cl); @@ -785,7 +743,6 @@ bool AWClauseContainer::remove(Clause* cl) */ Clause* AWClauseContainer::popSelected() { - CALL("AWClauseContainer::popSelected"); ASS( ! isEmpty()); _size--; diff --git a/Saturation/ClauseContainer.cpp b/Saturation/ClauseContainer.cpp index 81149c117..db21fb6e0 100644 --- a/Saturation/ClauseContainer.cpp +++ b/Saturation/ClauseContainer.cpp @@ -38,7 +38,6 @@ using namespace Indexing; void ClauseContainer::addClauses(ClauseIterator cit) { - CALL("ClauseContainer::addClauses"); while (cit.hasNext()) { add(cit.next()); } @@ -49,7 +48,6 @@ void ClauseContainer::addClauses(ClauseIterator cit) void RandomAccessClauseContainer::removeClauses(ClauseIterator cit) { - CALL("RandomAccessClauseContainer::removeClauses"); while (cit.hasNext()) { remove(cit.next()); } @@ -63,7 +61,6 @@ void RandomAccessClauseContainer::removeClauses(ClauseIterator cit) */ void RandomAccessClauseContainer::attach(SaturationAlgorithm* salg) { - CALL("RandomAccessClauseContainer::attach"); ASS(!_salg); _salg=salg; @@ -78,7 +75,6 @@ void RandomAccessClauseContainer::attach(SaturationAlgorithm* salg) */ void RandomAccessClauseContainer::detach() { - CALL("RandomAccessClauseContainer::detach"); ASS(_salg); _limitChangeSData->unsubscribe(); @@ -90,8 +86,6 @@ void RandomAccessClauseContainer::detach() UnprocessedClauseContainer::~UnprocessedClauseContainer() { - CALL("UnprocessedClauseContainer::~UnprocessedClauseContainer"); - while (!_data.isEmpty()) { Clause* cl=_data.pop_back(); ASS_EQ(cl->store(), Clause::UNPROCESSED); @@ -101,16 +95,12 @@ UnprocessedClauseContainer::~UnprocessedClauseContainer() void UnprocessedClauseContainer::add(Clause* c) { - CALL("UnprocessedClauseContainer::add"); - _data.push_back(c); addedEvent.fire(c); } Clause* UnprocessedClauseContainer::pop() { - CALL("UnprocessedClauseContainer::pop"); - Clause* res=_data.pop_back(); selectedEvent.fire(res); return res; @@ -118,7 +108,6 @@ Clause* UnprocessedClauseContainer::pop() void PassiveClauseContainer::updateLimits(long long estReachableCnt) { - CALL("PassiveClauseContainer::updateLimits"); ASS_GE(estReachableCnt,0); bool atLeastOneLimitTightened; @@ -161,7 +150,6 @@ void PassiveClauseContainer::updateLimits(long long estReachableCnt) void ActiveClauseContainer::add(Clause* c) { - CALL("ActiveClauseContainer::add"); TIME_TRACE("add clause") ASS(c->store()==Clause::ACTIVE); @@ -177,8 +165,6 @@ void ActiveClauseContainer::add(Clause* c) */ void ActiveClauseContainer::remove(Clause* c) { - CALL("ActiveClauseContainer::remove"); - ASS(c->store()==Clause::ACTIVE); ALWAYS(_clauses.remove(c)); removedEvent.fire(c); @@ -186,8 +172,6 @@ void ActiveClauseContainer::remove(Clause* c) void ActiveClauseContainer::onLimitsUpdated() { - CALL("ActiveClauseContainer::onLimitsUpdated"); - auto limits=getSaturationAlgorithm()->getPassiveClauseContainer(); ASS(limits); if (!limits->ageLimited() || !limits->weightLimited()) { diff --git a/Saturation/ConsequenceFinder.cpp b/Saturation/ConsequenceFinder.cpp index 9fa551c64..3c69b02ce 100644 --- a/Saturation/ConsequenceFinder.cpp +++ b/Saturation/ConsequenceFinder.cpp @@ -34,8 +34,6 @@ using namespace Kernel; void ConsequenceFinder::init(SaturationAlgorithm* sa) { - CALL("ConsequenceFinder::init"); - _sa=sa; ClauseContainer* cc=_sa->getSimplifyingClauseContainer(); @@ -45,16 +43,12 @@ void ConsequenceFinder::init(SaturationAlgorithm* sa) ConsequenceFinder::~ConsequenceFinder() { - CALL("ConsequenceFinder::~ConsequenceFinder"); - _sdInsertion->unsubscribe(); _sdRemoval->unsubscribe(); } void ConsequenceFinder::onNewPropositionalClause(Clause* cl) { - CALL("ConsequenceFinder::onNewPropositionalClause"); - TIME_TRACE(TimeTrace::CONSEQUENCE_FINDING); //remove duplicate literals (necessary for tautology deletion) @@ -115,8 +109,6 @@ void ConsequenceFinder::onNewPropositionalClause(Clause* cl) void ConsequenceFinder::onAllProcessed() { - CALL("ConsequenceFinder::onAllProcessed"); - TIME_TRACE(TimeTrace::CONSEQUENCE_FINDING); while(_redundantsToHandle.isNonEmpty()) { @@ -148,8 +140,6 @@ void ConsequenceFinder::onAllProcessed() */ bool ConsequenceFinder::isRedundant(Clause* cl) { - CALL("ConsequenceFinder::isRedundant"); - Clause::Iterator it(*cl); while(it.hasNext()) { unsigned fn=it.next()->functor(); @@ -166,8 +156,6 @@ bool ConsequenceFinder::isRedundant(Clause* cl) void ConsequenceFinder::onClauseInserted(Clause* cl) { - CALL("ConsequenceFinder::onClauseInserted"); - TIME_TRACE(TimeTrace::CONSEQUENCE_FINDING); bool red=false; @@ -197,8 +185,6 @@ void ConsequenceFinder::onClauseInserted(Clause* cl) void ConsequenceFinder::onClauseRemoved(Clause* cl) { - CALL("ConsequenceFinder::onClauseRemoved"); - TIME_TRACE(TimeTrace::CONSEQUENCE_FINDING); Clause::Iterator it(*cl); @@ -219,8 +205,6 @@ void ConsequenceFinder::onClauseRemoved(Clause* cl) */ void ConsequenceFinder::indexClause(unsigned indexNum, Clause* cl, bool add) { - CALL("ConsequenceFinder::indexClause"); - if(add) { if(!_index[indexNum]) { _index[indexNum]=new ClauseSL(); diff --git a/Saturation/Discount.cpp b/Saturation/Discount.cpp index 1aa8776f6..044beaf42 100644 --- a/Saturation/Discount.cpp +++ b/Saturation/Discount.cpp @@ -34,7 +34,6 @@ ClauseContainer* Discount::getSimplifyingClauseContainer() bool Discount::handleClauseBeforeActivation(Clause* cl) { - CALL("Discount::handleClauseBeforeActivation"); ASS(cl->store()==Clause::SELECTED); if (!forwardSimplify(cl)) { diff --git a/Saturation/ExtensionalityClauseContainer.cpp b/Saturation/ExtensionalityClauseContainer.cpp index 58dd1a763..4a16f2d5b 100644 --- a/Saturation/ExtensionalityClauseContainer.cpp +++ b/Saturation/ExtensionalityClauseContainer.cpp @@ -30,8 +30,6 @@ using namespace Shell; * X=Y, which is returned in case of a positive match, 0 otherwise. */ Literal* ExtensionalityClauseContainer::addIfExtensionality(Clause* c) { - CALL("ExtensionalityClauseContainer::addIfExtensionality"); - // Clause is already in extensionality container. We only have to search X=Y. if (c->isExtensionality()) { //cout << "Using " << c->toString() << endl; @@ -107,8 +105,6 @@ Literal* ExtensionalityClauseContainer::addIfExtensionality(Clause* c) { * places where we already know that @c c is an extensionality clause. */ Literal* ExtensionalityClauseContainer::getSingleVarEq(Clause* c) { - CALL("ExtensionalityClauseContainer::getSingleVarEq"); - for (unsigned i = 0; i < c->length(); ++i) { Literal* varEq = (*c)[i]; if (varEq->isTwoVarEquality() && varEq->isPositive()) { @@ -120,8 +116,6 @@ Literal* ExtensionalityClauseContainer::getSingleVarEq(Clause* c) { } void ExtensionalityClauseContainer::add(ExtensionalityClause c) { - CALL("ExtensionalityClauseContainer::add"); - ExtensionalityClauseList** l; _clausesBySort.getValuePtr(c.sort,l,ExtensionalityClauseList::empty()); ExtensionalityClauseList::push(c,*l); @@ -136,8 +130,6 @@ struct ExtensionalityClauseContainer::ActiveFilterFn ActiveFilterFn(ExtensionalityClauseContainer& parent) : _parent(parent) {} bool operator()(ExtensionalityClause extCl) { - CALL("ExtensionalityClauseContainer::ActiveFilterFn::operator()"); - if (extCl.clause->store() != Clause::ACTIVE) { extCl.clause->setExtensionality(false); _parent._size--; @@ -158,8 +150,6 @@ struct ExtensionalityClauseContainer::ActiveFilterFn * this lazily during generating inferences. */ ExtensionalityClauseIterator ExtensionalityClauseContainer::activeIterator(TermList sort) { - CALL("ExtensionalityClauseContainer::activeIterator"); - if(_clausesBySort.find(sort)){ return pvi(getFilteredDelIterator( ExtensionalityClauseList::DelIterator(_clausesBySort.get(sort)), @@ -170,8 +160,6 @@ ExtensionalityClauseIterator ExtensionalityClauseContainer::activeIterator(TermL } void ExtensionalityClauseContainer::print (ostream& out) { - CALL("ExtensionalityClauseContainer::print"); - out << "#####################" << endl; ClausesBySort::Iterator cbs(_clausesBySort); diff --git a/Saturation/LRS.cpp b/Saturation/LRS.cpp index 06a9290bb..a43c955d3 100644 --- a/Saturation/LRS.cpp +++ b/Saturation/LRS.cpp @@ -39,16 +39,12 @@ using namespace Shell; bool LRS::isComplete() { - CALL("LRS::isComplete"); - return !_limitsEverActive && SaturationAlgorithm::isComplete(); } void LRS::onUnprocessedSelected(Clause* c) { - CALL("LRS::onUnprocessedSelected"); - SaturationAlgorithm::onUnprocessedSelected(c); if(shouldUpdateLimits()) { @@ -73,8 +69,6 @@ void LRS::onUnprocessedSelected(Clause* c) */ bool LRS::shouldUpdateLimits() { - CALL("LRS::shouldUpdateLimits"); - static unsigned cnt=0; cnt++; @@ -92,8 +86,6 @@ bool LRS::shouldUpdateLimits() */ long long LRS::estimatedReachableCount() { - CALL("LRS::estimatedReachableCount"); - #if DETERMINISE_LRS_LOAD static std::ifstream infile("lrs_data.txt"); long long thing; diff --git a/Saturation/LabelFinder.cpp b/Saturation/LabelFinder.cpp index 585a0e61d..9e2b5d2c3 100644 --- a/Saturation/LabelFinder.cpp +++ b/Saturation/LabelFinder.cpp @@ -30,14 +30,10 @@ using namespace Kernel; LabelFinder::~LabelFinder() { - CALL("LabelFinder::~LabelFinder"); - } void LabelFinder::onNewPropositionalClause(Clause* cl) { - CALL("LabelFinder::onNewPropositionalClause"); - ASS(cl); // if we found a refutation ignore it if(Kernel::MainLoop::isRefutation(cl)) return; diff --git a/Saturation/ManCSPassiveClauseContainer.cpp b/Saturation/ManCSPassiveClauseContainer.cpp index bc57ea9e4..472e7543f 100644 --- a/Saturation/ManCSPassiveClauseContainer.cpp +++ b/Saturation/ManCSPassiveClauseContainer.cpp @@ -41,14 +41,12 @@ class VectorIteratorWrapper : public IteratorCore void ManCSPassiveClauseContainer::add(Clause* cl) { - CALL("ManCSPassiveClauseContainer::add"); clauses.push_back(cl); addedEvent.fire(cl); } void ManCSPassiveClauseContainer::remove(Clause* cl) { - CALL("ManCSPassiveClauseContainer::remove"); ASS(cl->store()==Clause::PASSIVE); auto it = std::find(clauses.begin(),clauses.end(),cl); @@ -61,7 +59,6 @@ void ManCSPassiveClauseContainer::remove(Clause* cl) Clause* ManCSPassiveClauseContainer::popSelected() { - CALL("ManCSPassiveClauseContainer::popSelected"); ASS(!clauses.empty()); std::vector::iterator selectedClauseIt; diff --git a/Saturation/Otter.cpp b/Saturation/Otter.cpp index 03324e19e..f43fdea66 100644 --- a/Saturation/Otter.cpp +++ b/Saturation/Otter.cpp @@ -40,8 +40,6 @@ ClauseContainer* Otter::getSimplifyingClauseContainer() void Otter::onActiveRemoved(Clause* cl) { - CALL("Otter::onActiveRemoved"); - if(cl->store()==Clause::ACTIVE) { _simplCont.remove(cl); } @@ -51,8 +49,6 @@ void Otter::onActiveRemoved(Clause* cl) void Otter::onPassiveAdded(Clause* cl) { - CALL("Otter::onPassiveAdded"); - SaturationAlgorithm::onPassiveAdded(cl); if(cl->store()==Clause::PASSIVE) { @@ -62,8 +58,6 @@ void Otter::onPassiveAdded(Clause* cl) void Otter::onPassiveRemoved(Clause* cl) { - CALL("Otter::onPassiveRemoved"); - if(cl->store()==Clause::PASSIVE) { _simplCont.remove(cl); } @@ -73,8 +67,6 @@ void Otter::onPassiveRemoved(Clause* cl) void Otter::onClauseRetained(Clause* cl) { - CALL("Otter::onClauseRetained"); - SaturationAlgorithm::onClauseRetained(cl); backwardSimplify(cl); @@ -82,7 +74,6 @@ void Otter::onClauseRetained(Clause* cl) void Otter::onSOSClauseAdded(Clause* cl) { - CALL("Otter::onSOSClauseAdded"); ASS(cl); ASS_EQ(cl->store(), Clause::ACTIVE); @@ -93,7 +84,6 @@ void Otter::onSOSClauseAdded(Clause* cl) void Otter::beforeSelectedRemoved(Clause* cl) { - CALL("Otter::beforeSelectedRemoved"); ASS_EQ(cl->store(), Clause::SELECTED); _simplCont.remove(cl); } diff --git a/Saturation/PredicateSplitPassiveClauseContainer.cpp b/Saturation/PredicateSplitPassiveClauseContainer.cpp index f3de768c1..017c2832e 100644 --- a/Saturation/PredicateSplitPassiveClauseContainer.cpp +++ b/Saturation/PredicateSplitPassiveClauseContainer.cpp @@ -36,8 +36,6 @@ PredicateSplitPassiveClauseContainer::PredicateSplitPassiveClauseContainer(bool Lib::vvector cutoffs, Lib::vvector ratios, bool layeredArrangement) : PassiveClauseContainer(isOutermost, opt, name), _queues(std::move(queues)), _cutoffs(cutoffs), _layeredArrangement(layeredArrangement) { - CALL("PredicateSplitPassiveClauseContainer::PredicateSplitPassiveClauseContainer"); - _randomize = opt.randomAWR(); // sanity checks @@ -74,13 +72,10 @@ PredicateSplitPassiveClauseContainer::PredicateSplitPassiveClauseContainer(bool } PredicateSplitPassiveClauseContainer::~PredicateSplitPassiveClauseContainer() { - CALL("PredicateSplitPassiveClauseContainer::~PredicateSplitPassiveClauseContainer"); } unsigned PredicateSplitPassiveClauseContainer::bestQueue(float featureValue) const { - CALL("PredicateSplitPassiveClauseContainer::bestQueue"); - // compute best queue clause should be placed in ASS(_cutoffs.back() == std::numeric_limits::max()); for (unsigned i = 0; i < _cutoffs.size(); i++) @@ -96,7 +91,6 @@ unsigned PredicateSplitPassiveClauseContainer::bestQueue(float featureValue) con void PredicateSplitPassiveClauseContainer::add(Clause* cl) { - CALL("PredicateSplitPassiveClauseContainer::add"); ASS(cl->store() == Clause::PASSIVE); auto bestQueueIndex = bestQueue(evaluateFeature(cl)); @@ -124,7 +118,6 @@ void PredicateSplitPassiveClauseContainer::add(Clause* cl) void PredicateSplitPassiveClauseContainer::remove(Clause* cl) { - CALL("PredicateSplitPassiveClauseContainer::remove"); if (_isOutermost) { ASS(cl->store()==Clause::PASSIVE); @@ -155,7 +148,6 @@ void PredicateSplitPassiveClauseContainer::remove(Clause* cl) bool PredicateSplitPassiveClauseContainer::isEmpty() const { - CALL("PredicateSplitPassiveClauseContainer::isEmpty"); for (const auto& queue : _queues) { if (!queue->isEmpty()) @@ -168,7 +160,6 @@ bool PredicateSplitPassiveClauseContainer::isEmpty() const unsigned PredicateSplitPassiveClauseContainer::sizeEstimate() const { - CALL("PredicateSplitPassiveClauseContainer::sizeEstimate"); ASS(!_queues.empty()); if (_layeredArrangement) @@ -190,8 +181,6 @@ unsigned PredicateSplitPassiveClauseContainer::sizeEstimate() const Clause* PredicateSplitPassiveClauseContainer::popSelected() { - CALL("PredicateSplitPassiveClauseContainer::popSelected"); - unsigned queueIndex; if (_randomize) { @@ -260,8 +249,6 @@ Clause* PredicateSplitPassiveClauseContainer::popSelected() void PredicateSplitPassiveClauseContainer::simulationInit() { - CALL("PredicateSplitPassiveClauseContainer::simulationInit"); - _simulationBalances.clear(); for (const auto& balance : _balances) { @@ -276,7 +263,6 @@ void PredicateSplitPassiveClauseContainer::simulationInit() bool PredicateSplitPassiveClauseContainer::simulationHasNext() { - CALL("PredicateSplitPassiveClauseContainer::simulationHasNext"); bool hasNext = false; for (const auto& queue : _queues) { @@ -288,7 +274,6 @@ bool PredicateSplitPassiveClauseContainer::simulationHasNext() void PredicateSplitPassiveClauseContainer::simulationPopSelected() { - CALL("PredicateSplitPassiveClauseContainer::simulationPopSelected"); // compute queue from which we will pick a clause: // choose queue using weighted round robin auto minElementIt = std::min_element(_simulationBalances.begin(), _simulationBalances.end()); @@ -327,7 +312,6 @@ void PredicateSplitPassiveClauseContainer::simulationPopSelected() // returns whether at least one of the limits was tightened bool PredicateSplitPassiveClauseContainer::setLimitsToMax() { - CALL("PredicateSplitPassiveClauseContainer::setLimitsToMax"); bool tightened = false; for (const auto& queue : _queues) { @@ -340,7 +324,6 @@ bool PredicateSplitPassiveClauseContainer::setLimitsToMax() // returns whether at least one of the limits was tightened bool PredicateSplitPassiveClauseContainer::setLimitsFromSimulation() { - CALL("PredicateSplitPassiveClauseContainer::setLimitsFromSimulation"); bool tightened = false; for (const auto& queue : _queues) { @@ -352,7 +335,6 @@ bool PredicateSplitPassiveClauseContainer::setLimitsFromSimulation() void PredicateSplitPassiveClauseContainer::onLimitsUpdated() { - CALL("PredicateSplitPassiveClauseContainer::onLimitsUpdated"); for (const auto& queue : _queues) { queue->onLimitsUpdated(); @@ -361,7 +343,6 @@ void PredicateSplitPassiveClauseContainer::onLimitsUpdated() bool PredicateSplitPassiveClauseContainer::ageLimited() const { - CALL("PredicateSplitPassiveClauseContainer::ageLimited"); for (const auto& queue : _queues) { if (queue->ageLimited()) @@ -374,7 +355,6 @@ bool PredicateSplitPassiveClauseContainer::ageLimited() const bool PredicateSplitPassiveClauseContainer::weightLimited() const { - CALL("PredicateSplitPassiveClauseContainer::weightLimited"); for (const auto& queue : _queues) { if (queue->weightLimited()) @@ -388,7 +368,6 @@ bool PredicateSplitPassiveClauseContainer::weightLimited() const // returns true if the cl fulfils at least one age-limit of a queue it is in bool PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(Clause* cl) const { - CALL("PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(Clause*)"); auto bestQueueIndex = bestQueue(evaluateFeature(cl)); if (_layeredArrangement) { @@ -413,7 +392,6 @@ bool PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(Clause* cl) const // this method internally takes care of computing the corresponding weightForClauseSelection. bool PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(unsigned w, unsigned numPositiveLiterals, const Inference& inference) const { - CALL("PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(unsigned, unsigned, const Inference&)"); auto bestQueueIndex = bestQueue(evaluateFeatureEstimate(numPositiveLiterals, inference)); // note: even for non-layered-arrangements, we need to go through all queues, since the values for age, w, ... are only lower bounds (in the sense that the actual value could lead to a worse bestQueueIndex) for (unsigned i = bestQueueIndex; i < _queues.size(); i++) @@ -431,7 +409,6 @@ bool PredicateSplitPassiveClauseContainer::fulfilsAgeLimit(unsigned w, unsigned // returns true if the cl fulfills at least one weight-limit of a queue it is in bool PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(Clause* cl) const { - CALL("PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(Clause*)"); auto bestQueueIndex = bestQueue(evaluateFeature(cl)); if (_layeredArrangement) { @@ -457,7 +434,6 @@ bool PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(Clause* cl) const bool PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(unsigned w, unsigned numPositiveLiterals, const Inference& inference) const { - CALL("PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(unsigned, unsigned, const Inference&)"); auto bestQueueIndex = bestQueue(evaluateFeatureEstimate(numPositiveLiterals, inference)); // note: even for non-layered-arrangements, we need to go through all queues, since the values for age, w, ... are only lower bounds (in the sense that the actual value could lead to a worse bestQueueIndex) for (unsigned i = bestQueueIndex; i < _queues.size(); i++) @@ -473,7 +449,6 @@ bool PredicateSplitPassiveClauseContainer::fulfilsWeightLimit(unsigned w, unsign bool PredicateSplitPassiveClauseContainer::childrenPotentiallyFulfilLimits(Clause* cl, unsigned upperBoundNumSelLits) const { - CALL("PredicateSplitPassiveClauseContainer::childrenPotentiallyFulfilLimits"); // can't conclude any lower bounds on niceness of child-clause, so have to assume that it is potentially added to all queues. // In particular we need to check whether at least one of the queues could potentially select children of the clause. for (const auto& queue : _queues) @@ -491,7 +466,6 @@ PredicateSplitPassiveClauseContainer(isOutermost, opt, name, std::move(queues), float TheoryMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const { - CALL("TheoryMultiSplitPassiveClauseContainer::evaluateFeature"); // heuristically compute likeliness that clause occurs in proof auto inference = cl->inference(); auto expectedRatioDenominator = _opt.theorySplitQueueExpectedRatioDenom(); @@ -500,7 +474,6 @@ float TheoryMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const float TheoryMultiSplitPassiveClauseContainer::evaluateFeatureEstimate(unsigned, const Inference& inf) const { - CALL("TheoryMultiSplitPassiveClauseContainer::evaluateFeatureEstimate"); // heuristically compute likeliness that clause occurs in proof static int expectedRatioDenominator = _opt.theorySplitQueueExpectedRatioDenom(); return inf.th_ancestors * expectedRatioDenominator - inf.all_ancestors; @@ -511,7 +484,6 @@ PredicateSplitPassiveClauseContainer(isOutermost, opt, name, std::move(queues), float AvatarMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const { - CALL("AvatarMultiSplitPassiveClauseContainer::evaluateFeature"); // heuristically compute likeliness that clause occurs in proof auto inf = cl->inference(); return (inf.splits() == nullptr) ? 0 : inf.splits()->size(); @@ -519,7 +491,6 @@ float AvatarMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const float AvatarMultiSplitPassiveClauseContainer::evaluateFeatureEstimate(unsigned, const Inference& inf) const { - CALL("AvatarMultiSplitPassiveClauseContainer::evaluateFeatureEstimate"); // heuristically compute likeliness that clause occurs in proof return (inf.splits() == nullptr) ? 0 : inf.splits()->size(); } @@ -529,14 +500,12 @@ PredicateSplitPassiveClauseContainer(isOutermost, opt, name, std::move(queues), float SineLevelMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const { - CALL("SineLevelMultiSplitPassiveClauseContainer::evaluateFeature"); // heuristically compute likeliness that clause occurs in proof return cl->getSineLevel(); } float SineLevelMultiSplitPassiveClauseContainer::evaluateFeatureEstimate(unsigned, const Inference& inf) const { - CALL("SineLevelMultiSplitPassiveClauseContainer::evaluateFeatureEstimate"); // heuristically compute likeliness that clause occurs in proof return inf.getSineLevel(); } @@ -546,14 +515,12 @@ PredicateSplitPassiveClauseContainer(isOutermost, opt, name, std::move(queues), float PositiveLiteralMultiSplitPassiveClauseContainer::evaluateFeature(Clause* cl) const { - CALL("PositiveLiteralMultiSplitPassiveClauseContainer::evaluateFeature"); // heuristically compute likeliness that clause occurs in proof return cl->numPositiveLiterals(); } float PositiveLiteralMultiSplitPassiveClauseContainer::evaluateFeatureEstimate(unsigned numPositiveLiterals, const Inference& inference) const { - CALL("PositiveLiteralMultiSplitPassiveClauseContainer::evaluateFeatureEstimate"); return numPositiveLiterals; } diff --git a/Saturation/ProvingHelper.cpp b/Saturation/ProvingHelper.cpp index 9392af232..61472c57c 100644 --- a/Saturation/ProvingHelper.cpp +++ b/Saturation/ProvingHelper.cpp @@ -50,8 +50,6 @@ using namespace Shell; */ void ProvingHelper::runVampireSaturation(Problem& prb, const Options& opt) { - CALL("ProvingHelper::runVampireSaturation"); - try { runVampireSaturationImpl(prb, opt); } @@ -87,8 +85,6 @@ using namespace Shell; */ void ProvingHelper::runVampire(Problem& prb, const Options& opt) { - CALL("ProvingHelper::runVampire"); - // when running a portfolio-mode worker, randomize for the first time for the preprocessing // (second time is in ProvingHelper::runVampireSaturationImpl, but not so important there) Lib::Random::setSeed(opt.randomSeed()); @@ -128,8 +124,6 @@ void ProvingHelper::runVampire(Problem& prb, const Options& opt) */ void ProvingHelper::runVampireSaturationImpl(Problem& prb, const Options& opt) { - CALL("ProvingHelper::runVampireSaturationImpl"); - Unit::onPreprocessingEnd(); if (env.options->showPreprocessing()) { env.beginOutput(); diff --git a/Saturation/SaturationAlgorithm.cpp b/Saturation/SaturationAlgorithm.cpp index 1ade5e1bb..e46d07f4c 100644 --- a/Saturation/SaturationAlgorithm.cpp +++ b/Saturation/SaturationAlgorithm.cpp @@ -225,7 +225,6 @@ SaturationAlgorithm::SaturationAlgorithm(Problem& prb, const Options& opt) _generatedClauseCount(0), _activationLimit(0) { - CALL("SaturationAlgorithm::SaturationAlgorithm"); ASS_EQ(s_instance, 0); //there can be only one saturation algorithm at a time _activationLimit = opt.activationLimit(); @@ -278,7 +277,6 @@ SaturationAlgorithm::SaturationAlgorithm(Problem& prb, const Options& opt) */ SaturationAlgorithm::~SaturationAlgorithm() { - CALL("SaturationAlgorithm::~SaturationAlgorithm"); ASS_EQ(s_instance,this); s_instance=0; @@ -325,8 +323,6 @@ SaturationAlgorithm::~SaturationAlgorithm() void SaturationAlgorithm::tryUpdateFinalClauseCount() { - CALL("SaturationAlgorithm::tryUpdateFinalClauseCount"); - SaturationAlgorithm* inst = tryGetInstance(); if (!inst) { return; @@ -348,8 +344,6 @@ bool SaturationAlgorithm::isComplete() ClauseIterator SaturationAlgorithm::activeClauses() { - CALL("SaturationAlgorithm::activeClauses"); - return _active->clauses(); } @@ -358,8 +352,6 @@ ClauseIterator SaturationAlgorithm::activeClauses() */ void SaturationAlgorithm::onActiveAdded(Clause* c) { - CALL("SaturationAlgorithm::onActiveAdded"); - if (env.options->showActive()) { env.beginOutput(); env.out() << "[SA] active: " << c->toString() << std::endl; @@ -372,8 +364,6 @@ void SaturationAlgorithm::onActiveAdded(Clause* c) */ void SaturationAlgorithm::onActiveRemoved(Clause* c) { - CALL("SaturationAlgorithm::onActiveRemoved"); - ASS(c->store()==Clause::ACTIVE); c->setStore(Clause::NONE); //at this point the c object may be deleted @@ -381,7 +371,6 @@ void SaturationAlgorithm::onActiveRemoved(Clause* c) void SaturationAlgorithm::onAllProcessed() { - CALL("SaturationAlgorithm::onAllProcessed"); ASS(clausesFlushed()); if (_symEl) { @@ -420,8 +409,6 @@ void SaturationAlgorithm::onPassiveAdded(Clause* c) */ void SaturationAlgorithm::onPassiveRemoved(Clause* c) { - CALL("SaturationAlgorithm::onPassiveRemoved"); - ASS(c->store()==Clause::PASSIVE); c->setStore(Clause::NONE); //at this point the c object can be deleted @@ -465,8 +452,6 @@ void SaturationAlgorithm::onUnprocessedSelected(Clause* c) */ void SaturationAlgorithm::onNewClause(Clause* cl) { - CALL("SaturationAlgorithm::onNewClause"); - if (_splitter) { _splitter->onNewClause(cl); } @@ -488,7 +473,6 @@ void SaturationAlgorithm::onNewClause(Clause* cl) void SaturationAlgorithm::onNewUsefulPropositionalClause(Clause* c) { - CALL("SaturationAlgorithm::onNewUsefulPropositionalClause"); ASS(c->isPropositional()); if (env.options->showNewPropositional()) { @@ -510,8 +494,6 @@ void SaturationAlgorithm::onNewUsefulPropositionalClause(Clause* c) */ void SaturationAlgorithm::onClauseRetained(Clause* cl) { - CALL("SaturationAlgorithm::onClauseRetained"); - //cout << "[SA] retained " << cl->toString() << endl; } @@ -523,7 +505,6 @@ void SaturationAlgorithm::onClauseRetained(Clause* cl) void SaturationAlgorithm::onClauseReduction(Clause* cl, Clause** replacements, unsigned numOfReplacements, Clause* premise, bool forward) { - CALL("SaturationAlgorithm::onClauseReduction/5"); ASS(cl); ClauseIterator premises; @@ -541,7 +522,6 @@ void SaturationAlgorithm::onClauseReduction(Clause* cl, Clause** replacements, u void SaturationAlgorithm::onClauseReduction(Clause* cl, Clause** replacements, unsigned numOfReplacements, ClauseIterator premises, bool forward) { - CALL("SaturationAlgorithm::onClauseReduction/4"); ASS(cl); static ClauseStack premStack; @@ -588,8 +568,6 @@ void SaturationAlgorithm::onClauseReduction(Clause* cl, Clause** replacements, u void SaturationAlgorithm::onNonRedundantClause(Clause* c) { - CALL("SaturationAlgorithm::onNonRedundantClause"); - if (_symEl) { _symEl->onNonRedundantClause(c); } @@ -605,8 +583,6 @@ void SaturationAlgorithm::onNonRedundantClause(Clause* c) */ void SaturationAlgorithm::onParenthood(Clause* cl, Clause* parent) { - CALL("SaturationAlgorithm::onParenthood"); - if (_symEl) { _symEl->onParenthood(cl, parent); } @@ -619,8 +595,6 @@ void SaturationAlgorithm::onParenthood(Clause* cl, Clause* parent) */ void SaturationAlgorithm::activeRemovedHandler(Clause* cl) { - CALL("SaturationAlgorithm::activeRemovedHandler"); - onActiveRemoved(cl); } @@ -631,8 +605,6 @@ void SaturationAlgorithm::activeRemovedHandler(Clause* cl) */ void SaturationAlgorithm::passiveRemovedHandler(Clause* cl) { - CALL("SaturationAlgorithm::passiveRemovedHandler"); - onPassiveRemoved(cl); } @@ -653,7 +625,6 @@ int SaturationAlgorithm::elapsedTime() */ void SaturationAlgorithm::addInputClause(Clause* cl) { - CALL("SaturationAlgorithm::addInputClause"); ASS_LE(toNumber(cl->inputType()),toNumber(UnitInputType::CLAIM)); // larger input types should not appear in proof search if (_symEl) { @@ -694,8 +665,6 @@ void SaturationAlgorithm::addInputClause(Clause* cl) */ LiteralSelector& SaturationAlgorithm::getSosLiteralSelector() { - CALL("SaturationAlgorithm::getSosLiteralSelector"); - if (_opt.sos() == Options::Sos::ALL || _opt.sos() == Options::Sos::THEORY) { if (!_sosLiteralSelector) { _sosLiteralSelector = new TotalLiteralSelector(getOrdering(), getOptions()); @@ -712,7 +681,6 @@ LiteralSelector& SaturationAlgorithm::getSosLiteralSelector() */ void SaturationAlgorithm::addInputSOSClause(Clause* cl) { - CALL("SaturationAlgorithm::addInputSOSClause"); ASS_EQ(toNumber(cl->inputType()),toNumber(UnitInputType::AXIOM)); //we add an extra reference until the clause is added to some container, so that @@ -767,8 +735,6 @@ void SaturationAlgorithm::addInputSOSClause(Clause* cl) */ void SaturationAlgorithm::init() { - CALL("SaturationAlgorithm::init"); - ClauseIterator toAdd; if (env.options->randomTraversals()) { @@ -803,7 +769,6 @@ void SaturationAlgorithm::init() Clause* SaturationAlgorithm::doImmediateSimplification(Clause* cl0) { - CALL("SaturationAlgorithm::doImmediateSimplification"); TIME_TRACE("immediate simplification"); static bool sosTheoryLimit = _opt.sos()==Options::Sos::THEORY; @@ -858,8 +823,6 @@ Clause* SaturationAlgorithm::doImmediateSimplification(Clause* cl0) */ void SaturationAlgorithm::addNewClause(Clause* cl) { - CALL("SaturationAlgorithm::addNewClause"); - if (env.options->randomTraversals()) { TIME_TRACE(TimeTrace::SHUFFLING); @@ -880,8 +843,6 @@ void SaturationAlgorithm::addNewClause(Clause* cl) void SaturationAlgorithm::newClausesToUnprocessed() { - CALL("SaturationAlgorithm::newClausesToUnprocessed"); - if (env.options->randomTraversals()) { TIME_TRACE(TimeTrace::SHUFFLING); @@ -933,8 +894,6 @@ bool SaturationAlgorithm::clausesFlushed() */ void SaturationAlgorithm::addUnprocessedClause(Clause* cl) { - CALL("SaturationAlgorithm::addUnprocessedClause"); - _generatedClauseCount++; env.statistics->generatedClauses++; @@ -965,7 +924,6 @@ void SaturationAlgorithm::addUnprocessedClause(Clause* cl) */ void SaturationAlgorithm::handleEmptyClause(Clause* cl) { - CALL("SaturationAlgorithm::handleEmptyClause"); ASS(cl->isEmpty()); if (isRefutation(cl)) { @@ -1018,7 +976,6 @@ void SaturationAlgorithm::handleEmptyClause(Clause* cl) */ bool SaturationAlgorithm::forwardSimplify(Clause* cl) { - CALL("SaturationAlgorithm::forwardSimplify"); TIME_TRACE("forward simplification"); if (!_passive->fulfilsAgeLimit(cl) && !_passive->fulfilsWeightLimit(cl)) { @@ -1088,7 +1045,6 @@ bool SaturationAlgorithm::forwardSimplify(Clause* cl) */ void SaturationAlgorithm::backwardSimplify(Clause* cl) { - CALL("SaturationAlgorithm::backwardSimplify"); TIME_TRACE("backward simplification"); @@ -1135,8 +1091,6 @@ void SaturationAlgorithm::backwardSimplify(Clause* cl) */ void SaturationAlgorithm::removeActiveOrPassiveClause(Clause* cl) { - CALL("SaturationAlgorithm::removeActiveOrPassiveClause"); - if (_clauseActivationInProgress) { //we cannot remove clause now, as there indexes might be traversed now, //and so we cannot modify them @@ -1165,7 +1119,6 @@ void SaturationAlgorithm::removeActiveOrPassiveClause(Clause* cl) */ void SaturationAlgorithm::addToPassive(Clause* cl) { - CALL("SaturationAlgorithm::addToPassive"); ASS_EQ(cl->store(), Clause::UNPROCESSED); cl->setStore(Clause::PASSIVE); @@ -1198,7 +1151,6 @@ void SaturationAlgorithm::removeSelected(Clause* cl) */ void SaturationAlgorithm::activate(Clause* cl) { - CALL("SaturationAlgorithm::activate"); TIME_TRACE("activation") { @@ -1286,8 +1238,6 @@ void SaturationAlgorithm::activate(Clause* cl) */ void SaturationAlgorithm::doUnprocessedLoop() { - CALL("SaturationAlgorithm::doUnprocessedLoop"); - start: newClausesToUnprocessed(); @@ -1340,16 +1290,12 @@ bool SaturationAlgorithm::handleClauseBeforeActivation(Clause* c) */ void SaturationAlgorithm::initAlgorithmRun() { - CALL("SaturationAlgorithm::initAlgorithmRun"); - init(); } UnitList* SaturationAlgorithm::collectSaturatedSet() { - CALL("SaturationAlgorithm::collectSaturatedSet"); - UnitList* res = 0; ClauseIterator it = _active->clauses(); while (it.hasNext()) { @@ -1366,8 +1312,6 @@ UnitList* SaturationAlgorithm::collectSaturatedSet() */ void SaturationAlgorithm::doOneAlgorithmStep() { - CALL("SaturationAlgorithm::doOneAlgorithmStep"); - doUnprocessedLoop(); if (_passive->isEmpty()) { @@ -1411,8 +1355,6 @@ void SaturationAlgorithm::doOneAlgorithmStep() */ MainLoopResult SaturationAlgorithm::runImpl() { - CALL("SaturationAlgorithm::runImpl"); - unsigned l = 0; try { @@ -1450,8 +1392,6 @@ MainLoopResult SaturationAlgorithm::runImpl() */ void SaturationAlgorithm::setGeneratingInferenceEngine(SimplifyingGeneratingInference* generator) { - CALL("SaturationAlgorithm::setGeneratingInferenceEngine"); - ASS(!_generator); _generator=generator; _generator->attach(this); @@ -1472,8 +1412,6 @@ void SaturationAlgorithm::setGeneratingInferenceEngine(SimplifyingGeneratingInfe */ void SaturationAlgorithm::setImmediateSimplificationEngine(ImmediateSimplificationEngine* immediateSimplifier) { - CALL("SaturationAlgorithm::setImmediateSimplificationEngine"); - ASS(!_immediateSimplifier); _immediateSimplifier=immediateSimplifier; _immediateSimplifier->attach(this); @@ -1516,8 +1454,6 @@ void SaturationAlgorithm::addBackwardSimplifierToFront(BackwardSimplificationEng */ SaturationAlgorithm* SaturationAlgorithm::createFromOptions(Problem& prb, const Options& opt, IndexManager* indexMgr) { - CALL("SaturationAlgorithm::createFromOptions"); - SaturationAlgorithm* res; switch(opt.saturationAlgorithm()) { case Shell::Options::SaturationAlgorithm::DISCOUNT: @@ -1777,8 +1713,6 @@ SaturationAlgorithm* SaturationAlgorithm::createFromOptions(Problem& prb, const */ ImmediateSimplificationEngine* SaturationAlgorithm::createISE(Problem& prb, const Options& opt, Ordering& ordering) { - CALL("MainLoop::createImmediateSE"); - CompositeISE* res=new CompositeISE(); if(prb.hasEquality() && opt.equationalTautologyRemoval()) { diff --git a/Saturation/Splitter.cpp b/Saturation/Splitter.cpp index 28f7ebc20..363dc72f7 100644 --- a/Saturation/Splitter.cpp +++ b/Saturation/Splitter.cpp @@ -62,8 +62,6 @@ using namespace Kernel; void SplittingBranchSelector::init() { - CALL("SplittingBranchSelector::init"); - _eagerRemoval = _parent.getOptions().splittingEagerRemoval(); _literalPolarityAdvice = _parent.getOptions().splittingLiteralPolarityAdvice(); @@ -121,8 +119,6 @@ void SplittingBranchSelector::init() void SplittingBranchSelector::updateVarCnt() { - CALL("SplittingBranchSelector::updateVarCnt"); - unsigned satVarCnt = _parent.maxSatVar(); unsigned splitLvlCnt = _parent.splitLevelCnt(); @@ -139,8 +135,6 @@ void SplittingBranchSelector::updateVarCnt() */ void SplittingBranchSelector::considerPolarityAdvice(SATLiteral lit) { - CALL("SplittingBranchSelector::considerPolarityAdvice"); - switch (_literalPolarityAdvice) { case Options::SplittingLiteralPolarityAdvice::FALSE: _solver->suggestPolarity(lit.var(),lit.oppositePolarity()); @@ -186,8 +180,6 @@ static Color colorFromPossiblyDeepFOConversion(SATClause* scl,Unit*& u) void SplittingBranchSelector::handleSatRefutation() { - CALL("SplittingBranchSelector::handleSatRefutation"); - SATClause* satRefutation = _solver->getRefutation(); SATClauseList* satPremises = env.options->minimizeSatProofs() ? _solver->getRefutationPremiseList() : nullptr; // getRefutationPremiseList may be nullptr already, if our solver does not support minimization @@ -326,8 +318,6 @@ void SplittingBranchSelector::handleSatRefutation() } SATSolver::VarAssignment SplittingBranchSelector::getSolverAssimentConsideringCCModel(unsigned var) { - CALL("SplittingBranchSelector::getSolverAssimentConsideringCCModel"); - if (_ccModel) { // if we work with ccModel, the cc-model overrides the satsolver, but only for positive ground equalities SAT2FO& s2f = _parent.satNaming(); @@ -356,8 +346,6 @@ static const unsigned AGE_NOT_FILLED = UINT_MAX; int SplittingBranchSelector::assertedGroundPositiveEqualityCompomentMaxAge() { - CALL("SplittingBranchSelector::assertedGroundPositiveEqualityCompomentMaxAge"); - int max = 0; unsigned maxSatVar = _parent.maxSatVar(); @@ -390,7 +378,6 @@ int SplittingBranchSelector::assertedGroundPositiveEqualityCompomentMaxAge() SATSolver::Status SplittingBranchSelector::processDPConflicts() { - CALL("SplittingBranchSelector::processDPConflicts"); // ASS(_solver->getStatus()==SATSolver::SATISFIABLE); if(!_dp) { @@ -519,7 +506,6 @@ SATSolver::Status SplittingBranchSelector::processDPConflicts() void SplittingBranchSelector::updateSelection(unsigned satVar, SATSolver::VarAssignment asgn, SplitLevelStack& addedComps, SplitLevelStack& removedComps) { - CALL("SplittingBranchSelector::updateSelection"); ASS_NEQ(asgn, SATSolver::NOT_KNOWN); //we always do full SAT solving, so there shouldn't be unknown variables SplitLevel posLvl = _parent.getNameFromLiteral(SATLiteral(satVar, true)); @@ -565,8 +551,6 @@ void SplittingBranchSelector::updateSelection(unsigned satVar, SATSolver::VarAss void SplittingBranchSelector::addSatClauseToSolver(SATClause* cl, bool branchRefutation) { - CALL("SplittingBranchSelector::addSatClauseToSolver"); - cl = SATClause::removeDuplicateLiterals(cl); if(!cl) { RSTAT_CTR_INC("splitter_tautology"); @@ -584,7 +568,6 @@ void SplittingBranchSelector::addSatClauseToSolver(SATClause* cl, bool branchRef void SplittingBranchSelector::recomputeModel(SplitLevelStack& addedComps, SplitLevelStack& removedComps, bool randomize) { - CALL("SplittingBranchSelector::recomputeModel"); ASS(addedComps.isEmpty()); ASS(removedComps.isEmpty()); @@ -637,7 +620,6 @@ Splitter::Splitter() : _deleteDeactivated(Options::SplittingDeleteDeactivated::ON), _branchSelector(*this), _clausesAdded(false), _haveBranchRefutation(false) { - CALL("Splitter::Splitter"); if(env.options->proof()==Options::Proof::TPTP){ unsigned spl = env.signature->addFreshFunction(0,"spl"); splPrefix = env.signature->functionName(spl)+"_"; @@ -646,8 +628,6 @@ Splitter::Splitter() Splitter::~Splitter() { - CALL("Splitter::~Splitter"); - while(_db.isNonEmpty()) { if(_db.top()) { delete _db.top(); @@ -658,7 +638,6 @@ Splitter::~Splitter() const Options& Splitter::getOptions() const { - CALL("Splitter::getOptions"); ASS(_sa); return _sa->getOptions(); @@ -666,7 +645,6 @@ const Options& Splitter::getOptions() const Ordering& Splitter::getOrdering() const { - CALL("Splitter::getOrdering"); ASS(_sa); return _sa->getOrdering(); @@ -675,8 +653,6 @@ Ordering& Splitter::getOrdering() const void Splitter::init(SaturationAlgorithm* sa) { - CALL("Splitter::init"); - _sa = sa; const Options& opts = getOptions(); @@ -721,8 +697,6 @@ void Splitter::init(SaturationAlgorithm* sa) SplitLevel Splitter::getNameFromLiteral(SATLiteral lit) const { - CALL("Splitter::getNameFromLiteral"); - SplitLevel res = getNameFromLiteralUnsafe(lit); ASS_L(res, _db.size()); return res; @@ -735,22 +709,16 @@ SplitLevel Splitter::getNameFromLiteral(SATLiteral lit) const */ SplitLevel Splitter::getNameFromLiteralUnsafe(SATLiteral lit) const { - CALL("Splitter::getNameFromLiteralUnsafe"); - return (lit.var()-1)*2 + (lit.polarity() ? 0 : 1); } SATLiteral Splitter::getLiteralFromName(SplitLevel compName) { - CALL("Splitter::getLiteralFromName"); - unsigned var = compName/2 + 1; bool polarity = (compName&1)==0; return SATLiteral(var, polarity); } vstring Splitter::getFormulaStringFromName(SplitLevel compName, bool negated) { - CALL("Splitter::getFormulaStringFromName"); - SATLiteral lit = getLiteralFromName(compName); if (negated) { lit = lit.opposite(); @@ -764,8 +732,6 @@ vstring Splitter::getFormulaStringFromName(SplitLevel compName, bool negated) Unit* Splitter::getDefinitionFromName(SplitLevel compName) const { - CALL("Splitter::getDefinitionFromName"); - // always stored positively return _defs.get(compName & ~1); } @@ -781,7 +747,6 @@ void Splitter::collectDependenceLits(SplitSet* splits, SATLiteralStack& acc) con Clause* Splitter::getComponentClause(SplitLevel name) const { - CALL("Splitter::getComponentClause"); ASS_L(name,_db.size()); ASS_NEQ(_db[name],0); @@ -790,8 +755,6 @@ Clause* Splitter::getComponentClause(SplitLevel name) const void Splitter::onAllProcessed() { - CALL("Splitter::onAllProcessed"); - bool flushing = false; if(_flushPeriod) { if(_haveBranchRefutation) { @@ -864,8 +827,6 @@ void Splitter::onAllProcessed() bool Splitter::shouldAddClauseForNonSplittable(Clause* cl, unsigned& compName, Clause*& compCl) { - CALL("Splitter::shouldAddClauseForNonSplittable"); - if((_congruenceClosure != Options::SplittingCongruenceClosure::OFF #if VZ3 || hasSMTSolver @@ -913,8 +874,6 @@ bool Splitter::shouldAddClauseForNonSplittable(Clause* cl, unsigned& compName, C bool Splitter::handleNonSplittable(Clause* cl) { - CALL("Splitter::handleNonSplittable"); - SplitLevel compName; Clause* compCl; if(!shouldAddClauseForNonSplittable(cl, compName, compCl)) { @@ -999,8 +958,6 @@ bool Splitter::handleNonSplittable(Clause* cl) */ vstring Splitter::splitsToString(SplitSet* splits) { - CALL("Splitter::splitsToString"); - vostringstream res; typename SplitSet::Iterator it(*splits); @@ -1026,7 +983,6 @@ vstring Splitter::splitsToString(SplitSet* splits) */ bool Splitter::getComponents(Clause* cl, Stack& acc, bool shuffle) { - CALL("Splitter::getComponents"); ASS_EQ(acc.size(), 0); unsigned clen=cl->length(); @@ -1090,8 +1046,6 @@ bool Splitter::getComponents(Clause* cl, Stack& acc, bool shuffle) */ bool Splitter::doSplitting(Clause* cl) { - CALL("Splitter::doSplitting"); - static bool hasStopped = false; if (hasStopped) { return false; @@ -1190,8 +1144,6 @@ bool Splitter::doSplitting(Clause* cl) */ bool Splitter::tryGetExistingComponentName(unsigned size, Literal* const * lits, SplitLevel& comp, Clause*& compCl) { - CALL("Splitter::tryGetExistingComponentName"); - ClauseIterator existingComponents; { TIME_TRACE("splitting component index usage"); @@ -1227,7 +1179,6 @@ bool Splitter::tryGetExistingComponentName(unsigned size, Literal* const * lits, */ Clause* Splitter::buildAndInsertComponentClause(SplitLevel name, unsigned size, Literal* const * lits, Clause* orig) { - CALL("Splitter::buildAndInsertComponentClause"); ASS_EQ(_db[name],0); /** @@ -1311,7 +1262,6 @@ Clause* Splitter::buildAndInsertComponentClause(SplitLevel name, unsigned size, SplitLevel Splitter::addNonGroundComponent(unsigned size, Literal* const * lits, Clause* orig, Clause*& compCl) { - CALL("Splitter::addNonGroundComponent"); ASS_REP(_db.size()%2==0, _db.size()); ASS_G(size,0); ASS(forAll(getArrayishObjectIterator(lits, size), @@ -1335,7 +1285,6 @@ SplitLevel Splitter::addNonGroundComponent(unsigned size, Literal* const * lits, SplitLevel Splitter::addGroundComponent(Literal* lit, Clause* orig, Clause*& compCl) { - CALL("Splitter::addGroundComponent"); ASS_REP(_db.size()%2==0, _db.size()); ASS(lit->ground()); @@ -1378,7 +1327,6 @@ SplitLevel Splitter::addGroundComponent(Literal* lit, Clause* orig, Clause*& com */ SplitLevel Splitter::tryGetComponentNameOrAddNew(const LiteralStack& comp, Clause* orig, Clause*& compCl) { - CALL("Splitter::getComponentName/3"); return tryGetComponentNameOrAddNew(comp.size(), comp.begin(), orig, compCl); } @@ -1393,8 +1341,6 @@ SplitLevel Splitter::tryGetComponentNameOrAddNew(const LiteralStack& comp, Claus */ SplitLevel Splitter::tryGetComponentNameOrAddNew(unsigned size, Literal* const * lits, Clause* orig, Clause*& compCl) { - CALL("Splitter::getComponentName/4"); - SplitLevel res; if(tryGetExistingComponentName(size, lits, res, compCl)) { @@ -1420,7 +1366,6 @@ static const int NOT_WORTH_REINTRODUCING = 0; */ void Splitter::assignClauseSplitSet(Clause* cl, SplitSet* splits) { - CALL("Splitter::assignClauseSplitSet"); ASS(!cl->splits()); cl->setSplits(splits); @@ -1457,7 +1402,6 @@ void Splitter::assignClauseSplitSet(Clause* cl, SplitSet* splits) */ void Splitter::onClauseReduction(Clause* cl, ClauseIterator premises, Clause* replacement) { - CALL("Splitter::onClauseReduction"); ASS(cl); if(!premises.hasNext()) { @@ -1528,8 +1472,6 @@ void Splitter::onClauseReduction(Clause* cl, ClauseIterator premises, Clause* re bool Splitter::allSplitLevelsActive(SplitSet* s) { - CALL("Splitter::allSplitLevelsActive"); - SplitSet::Iterator sit(*s); while(sit.hasNext()) { SplitLevel lev=sit.next(); @@ -1544,8 +1486,6 @@ bool Splitter::allSplitLevelsActive(SplitSet* s) void Splitter::onNewClause(Clause* cl) { - CALL("Splitter::onNewClause"); - //For now just record if cl is in the variant index // i.e. is a component //TODO - if it is then @@ -1594,8 +1534,6 @@ void Splitter::onNewClause(Clause* cl) */ SplitSet* Splitter::getNewClauseSplitSet(Clause* cl) { - CALL("Splitter::getNewClauseSplitSet"); - SplitSet* res; Inference& inf= cl->inference(); Inference::Iterator it=inf.iterator(); @@ -1621,7 +1559,6 @@ SplitSet* Splitter::getNewClauseSplitSet(Clause* cl) Splitter::SplitRecord::~SplitRecord() { - CALL("Splitter::SplitRecord::~SplitRecord"); component->decRefCnt(); while(reduced.isNonEmpty()) { Clause* cl = reduced.pop().clause; @@ -1634,15 +1571,11 @@ Splitter::SplitRecord::~SplitRecord() */ void Splitter::SplitRecord::addReduced(Clause* cl) { - CALL("Splitter::SplitRecord::addReduced"); - cl->incRefCnt(); //dec when popped from the '_db[slev]->reduced' stack in backtrack method reduced.push(ReductionRecord(cl)); } void Splitter::addSatClauseToSolver(SATClause* cl, bool refutation) { - CALL("Splitter::addSatClauseToSolver"); - _clausesAdded = true; if (refutation) { _haveBranchRefutation = true; @@ -1652,8 +1585,6 @@ void Splitter::addSatClauseToSolver(SATClause* cl, bool refutation) { bool Splitter::handleEmptyClause(Clause* cl) { - CALL("Splitter::handleEmptyClause"); - if(cl->splits()->isEmpty()) { return false; } @@ -1702,8 +1633,6 @@ bool Splitter::handleEmptyClause(Clause* cl) void Splitter::addComponents(const SplitLevelStack& toAdd) { - CALL("Splitter::addComponents"); - SplitLevelStack::ConstIterator slit(toAdd); while(slit.hasNext()) { SplitLevel sl = slit.next(); @@ -1742,7 +1671,6 @@ void Splitter::addComponents(const SplitLevelStack& toAdd) */ void Splitter::removeComponents(const SplitLevelStack& toRemove) { - CALL("Splitter::removeComponents"); ASS(_sa->clausesFlushed()); SplitSet* backtracked = SplitSet::getFromArray(toRemove.begin(), toRemove.size()); @@ -1822,8 +1750,6 @@ void Splitter::removeComponents(const SplitLevelStack& toRemove) */ UnitList* Splitter::preprendCurrentlyAssumedComponentClauses(UnitList* clauses) { - CALL("Splitter::preprendCurrentlyAssumedComponentClauses"); - DHSet seen; UnitList* res = nullptr; diff --git a/Saturation/Splitter.hpp b/Saturation/Splitter.hpp index ab09939d6..7db05cef3 100644 --- a/Saturation/Splitter.hpp +++ b/Saturation/Splitter.hpp @@ -202,7 +202,6 @@ class Splitter { static vstring getFormulaStringFromName(SplitLevel compName, bool negated = false); bool isUsedName(SplitLevel name) const { - CALL("Splitter::isUsedName"); ASS_L(name,_db.size()); return (_db[name] != 0); } diff --git a/Saturation/SymElOutput.cpp b/Saturation/SymElOutput.cpp index 08775102d..3038259a3 100644 --- a/Saturation/SymElOutput.cpp +++ b/Saturation/SymElOutput.cpp @@ -36,31 +36,23 @@ SymElOutput::SymElOutput() void SymElOutput::init(SaturationAlgorithm* sa) { - CALL("SymElOutput::init"); - _sa=sa; } void SymElOutput::onAllProcessed() { - CALL("SymElOutput::onAllProcessed"); - _symElRewrites.reset(); _symElColors.reset(); } void SymElOutput::onInputClause(Clause* c) { - CALL("SymElOutput::onInputClause"); - checkForPreprocessorSymbolElimination(c); } void SymElOutput::onNonRedundantClause(Clause* c) { - CALL("SymElOutput::onNonRedundantClause"); - if(c->color()==COLOR_TRANSPARENT && !c->skip()) { Clause* tgt=c; Clause* src; @@ -93,8 +85,6 @@ void SymElOutput::onNonRedundantClause(Clause* c) */ void SymElOutput::onParenthood(Clause* cl, Clause* parent) { - CALL("SymElOutput::onParenthood"); - Color pcol=parent->color(); // Clause::Store pstore=parent->store(); @@ -115,7 +105,6 @@ void SymElOutput::onParenthood(Clause* cl, Clause* parent) void SymElOutput::onSymbolElimination(Color eliminated, Clause* c, bool nonRedundant) { - CALL("SymElOutput::onSymbolElimination"); ASS_EQ(c->color(),COLOR_TRANSPARENT); if(!c->skip() && c->noSplits()) { @@ -134,7 +123,6 @@ void SymElOutput::onSymbolElimination(Color eliminated, void SymElOutput::outputSymbolElimination(Color eliminated, Clause* c) { - CALL("SymElOutput::outputSymbolElimination"); ASS_EQ(c->color(),COLOR_TRANSPARENT); ASS(!c->skip()); @@ -167,8 +155,6 @@ void SymElOutput::outputSymbolElimination(Color eliminated, Clause* c) void SymElOutput::checkForPreprocessorSymbolElimination(Clause* cl) { - CALL("SymElOutput::checkForPreprocessorSymbolElimination"); - if(!env.colorUsed || cl->color()!=COLOR_TRANSPARENT || cl->skip()) { return; } diff --git a/Shell/AnswerExtractor.cpp b/Shell/AnswerExtractor.cpp index a268c2c24..f21594802 100644 --- a/Shell/AnswerExtractor.cpp +++ b/Shell/AnswerExtractor.cpp @@ -42,8 +42,6 @@ namespace Shell void AnswerExtractor::tryOutputAnswer(Clause* refutation) { - CALL("AnswerExtractor::tryOutputAnswer"); - Stack answer; if(!AnswerLiteralManager::getInstance()->tryGetAnswer(refutation, answer)) { @@ -86,8 +84,6 @@ void AnswerExtractor::tryOutputAnswer(Clause* refutation) void AnswerExtractor::getNeededUnits(Clause* refutation, ClauseStack& premiseClauses, Stack& conjectures) { - CALL("AnswerExtractor::getNeededUnits"); - InferenceStore& is = *InferenceStore::instance(); DHSet seen; @@ -126,7 +122,6 @@ class ConjunctionGoalAnswerExractor::SubstBuilder {} ~SubstBuilder() { - CALL("ConjunctionGoalAnswerExractor::SubstBuilder::~SubstBuilder"); for(unsigned i=0; i<_goalCnt; i++) { _btData[i].drop(); } @@ -134,8 +129,6 @@ class ConjunctionGoalAnswerExractor::SubstBuilder bool run() { - CALL("ConjunctionGoalAnswerExractor::SubstBuilder::run"); - _depth = 0; enterGoal(); for(;;) { @@ -164,23 +157,17 @@ class ConjunctionGoalAnswerExractor::SubstBuilder void enterGoal() { - CALL("ConjunctionGoalAnswerExractor::SubstBuilder::enterGoal"); - _unifIts[_depth] = _lemmas.getUnifications(_goalLits[_depth], false, false); _triedEqUnif[_depth] = false; _subst.bdRecord(_btData[_depth]); } void leaveGoal() { - CALL("ConjunctionGoalAnswerExractor::SubstBuilder::leaveGoal"); - _subst.bdDone(); _btData[_depth].backtrack(); } bool nextGoalUnif() { - CALL("ConjunctionGoalAnswerExractor::SubstBuilder::nextGoalUnif"); - Literal* goalLit = _goalLits[_depth]; while(_unifIts[_depth].hasNext()) { @@ -214,8 +201,6 @@ class ConjunctionGoalAnswerExractor::SubstBuilder bool ConjunctionGoalAnswerExractor::tryGetAnswer(Clause* refutation, Stack& answer) { - CALL("ConjunctionGoalAnswerExractor::tryGetAnswer"); - ClauseStack premiseClauses; Stack conjectures; getNeededUnits(refutation, premiseClauses, conjectures); @@ -300,8 +285,6 @@ bool ConjunctionGoalAnswerExractor::tryGetAnswer(Clause* refutation, Stack& answer) { - CALL("AnswerLiteralManager::tryGetAnswer"); - RCClauseStack::Iterator cit(_answers); while(cit.hasNext()) { Clause* ansCl = cit.next(); @@ -329,8 +310,6 @@ bool AnswerLiteralManager::tryGetAnswer(Clause* refutation, Stack& ans Literal* AnswerLiteralManager::getAnswerLiteral(VList* vars,Formula* f) { - CALL("AnswerLiteralManager::getAnswerLiteral"); - static Stack litArgs; litArgs.reset(); VList::Iterator vit(vars); @@ -354,8 +333,6 @@ Literal* AnswerLiteralManager::getAnswerLiteral(VList* vars,Formula* f) Unit* AnswerLiteralManager::tryAddingAnswerLiteral(Unit* unit) { - CALL("AnswerLiteralManager::tryAddingAnswerLiteral"); - if(unit->isClause() || unit->inputType()!=UnitInputType::CONJECTURE) { return unit; } @@ -389,8 +366,6 @@ Unit* AnswerLiteralManager::tryAddingAnswerLiteral(Unit* unit) void AnswerLiteralManager::addAnswerLiterals(Problem& prb) { - CALL("AnswerLiteralManager::addAnswerLiterals"); - if(addAnswerLiterals(prb.units())) { prb.invalidateProperty(); } @@ -402,8 +377,6 @@ void AnswerLiteralManager::addAnswerLiterals(Problem& prb) */ bool AnswerLiteralManager::addAnswerLiterals(UnitList*& units) { - CALL("AnswerLiteralManager::addAnswerLiterals"); - bool someAdded = false; UnitList::DelIterator uit(units); while(uit.hasNext()) { @@ -419,8 +392,6 @@ bool AnswerLiteralManager::addAnswerLiterals(UnitList*& units) bool AnswerLiteralManager::isAnswerLiteral(Literal* lit) { - CALL("AnswerLiteralManager::isAnswerLiteral"); - unsigned pred = lit->functor(); Signature::Symbol* sym = env.signature->getPredicate(pred); return sym->answerPredicate(); @@ -428,8 +399,6 @@ bool AnswerLiteralManager::isAnswerLiteral(Literal* lit) void AnswerLiteralManager::onNewClause(Clause* cl) { - CALL("AnswerLiteralManager::onNewClause"); - if(!cl->noSplits()) { return; } @@ -454,8 +423,6 @@ void AnswerLiteralManager::onNewClause(Clause* cl) Clause* AnswerLiteralManager::getResolverClause(unsigned pred) { - CALL("AnswerLiteralManager::getResolverClause"); - Clause* res; if(_resolverClauses.find(pred, res)) { return res; @@ -480,8 +447,6 @@ Clause* AnswerLiteralManager::getResolverClause(unsigned pred) Clause* AnswerLiteralManager::getRefutation(Clause* answer) { - CALL("AnswerLiteralManager::getRefutation"); - unsigned clen = answer->length(); UnitList* premises = 0; UnitList::push(answer, premises); diff --git a/Shell/BlockedClauseElimination.cpp b/Shell/BlockedClauseElimination.cpp index 23059d5c5..7e098d37a 100644 --- a/Shell/BlockedClauseElimination.cpp +++ b/Shell/BlockedClauseElimination.cpp @@ -50,8 +50,6 @@ using namespace Indexing; void BlockedClauseElimination::apply(Problem& prb) { - CALL("BlockedClauseElimination::apply(Problem&)"); - TIME_TRACE("blocked clause elimination"); bool modified = false; @@ -192,8 +190,6 @@ void BlockedClauseElimination::apply(Problem& prb) bool BlockedClauseElimination::resolvesToTautology(bool equationally, Clause* cl, Literal* lit, Clause* pcl, Literal* plit) { - CALL("BlockedClauseElimination::resolvesToTautology"); - if (equationally) { return resolvesToTautologyEq(cl,lit,pcl,plit); } else { @@ -253,8 +249,6 @@ class RenanigApartNormalizer : public TermTransformer { bool BlockedClauseElimination::resolvesToTautologyEq(Clause* cl, Literal* lit, Clause* pcl, Literal* plit) { - CALL("BlockedClauseElimination::resolvesToTautologyEq"); - // With polymorphism, some intermediate terms created here are not well sorted, but that's OK TermSharing::WellSortednessCheckingLocalDisabler disableInScope(env.sharing); // cout << "cl: " << cl->toString() << endl; @@ -431,8 +425,6 @@ struct TimesTwoPlusOne { bool BlockedClauseElimination::resolvesToTautologyEq(Clause* cl, Literal* lit, Clause* pcl, Literal* plit) { - CALL("BlockedClauseElimination::resolvesToTautologyEq"); - _cc.reset(); // cout << "cl: " << cl->toString() << endl; @@ -496,8 +488,6 @@ bool BlockedClauseElimination::resolvesToTautologyEq(Clause* cl, Literal* lit, C bool BlockedClauseElimination::resolvesToTautologyUn(Clause* cl, Literal* lit, Clause* pcl, Literal* plit) { - CALL("BlockedClauseElimination::resolvesToTautologyUn"); - // cout << "cl: " << cl->toString() << endl; // cout << "pcl: " << pcl->toString() << endl; // cout << "lit: " << lit->toString() << endl; diff --git a/Shell/CNF.cpp b/Shell/CNF.cpp index 68b725054..7b792f5fb 100644 --- a/Shell/CNF.cpp +++ b/Shell/CNF.cpp @@ -14,7 +14,6 @@ * @since 27/12/2007 Manchester, changed completely to a new implementation */ -#include "Debug/Tracer.hpp" #include "Kernel/Clause.hpp" #include "Kernel/Formula.hpp" @@ -42,7 +41,6 @@ CNF::CNF() */ void CNF::clausify (Unit* unit,Stack& stack) { - CALL("CNF::clausify/2"); ASS(! unit->isClause()); _unit = static_cast(unit); @@ -78,8 +76,6 @@ void CNF::clausify (Unit* unit,Stack& stack) */ void CNF::clausify (Formula* f) { - CALL("CNF::clausify/1"); - switch (f->connective()) { case LITERAL: _literals.push(f->literal()); diff --git a/Shell/CommandLine.cpp b/Shell/CommandLine.cpp index 3c2c0470d..9689e57ce 100644 --- a/Shell/CommandLine.cpp +++ b/Shell/CommandLine.cpp @@ -18,7 +18,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/VString.hpp" #include "Lib/Environment.hpp" @@ -35,7 +34,6 @@ CommandLine::CommandLine (int argc, char* argv []) : _next(argv+1), _last(argv+argc) { - CALL ("CommandLine::CommandLine"); } // CommandLine::CommandLine /** @@ -49,8 +47,6 @@ CommandLine::CommandLine (int argc, char* argv []) */ void CommandLine::interpret (Options& options) { - CALL ("CommandLine::interpret"); - bool fileGiven = false; while (_next != _last) { ASS(_next < _last); diff --git a/Shell/DistinctGroupExpansion.cpp b/Shell/DistinctGroupExpansion.cpp index 4a2d0e3ac..8c15785c4 100644 --- a/Shell/DistinctGroupExpansion.cpp +++ b/Shell/DistinctGroupExpansion.cpp @@ -38,8 +38,6 @@ using namespace Shell; */ void DistinctGroupExpansion::apply(Problem& prb) { - CALL("DistinctGroupExpansion::apply(Problem&)"); - if(apply(prb.units())){ prb.invalidateProperty(); prb.reportFormulasAdded(); @@ -56,8 +54,6 @@ void DistinctGroupExpansion::apply(Problem& prb) */ bool DistinctGroupExpansion::apply(UnitList*& units) { - CALL("DistinctGroupExpansion::apply(UnitList*&)"); - bool added=false; Stack& group_members = env.signature->distinctGroupMembers(); @@ -99,8 +95,6 @@ bool DistinctGroupExpansion::apply(UnitList*& units) */ Formula* DistinctGroupExpansion::expand(Stack& constants) { - CALL("DistinctGroupExpansion::expand"); - ASS(constants.size()>=2); // If there are 2 just create a disequality if(constants.size()==2){ diff --git a/Shell/DistinctProcessor.cpp b/Shell/DistinctProcessor.cpp index 1eecf410d..172a47b75 100644 --- a/Shell/DistinctProcessor.cpp +++ b/Shell/DistinctProcessor.cpp @@ -33,8 +33,6 @@ namespace Shell */ bool DistinctProcessor::isDistinctPred(Literal* l) { - CALL("DistinctProcessor::isDistinctPred"); - //this is a hacky way to check for disctnct predicates, //needs to be fixed once we have a proper sopport for //these in the signature @@ -48,8 +46,6 @@ bool DistinctProcessor::isDistinctPred(Literal* l) bool DistinctProcessor::apply(FormulaUnit* unit, Unit*& res) { - CALL("DistinctProcessor::apply"); - Formula* form = unit->formula(); diff --git a/Shell/DistinctProcessor.hpp b/Shell/DistinctProcessor.hpp index 359af1c98..1ec8a7b49 100644 --- a/Shell/DistinctProcessor.hpp +++ b/Shell/DistinctProcessor.hpp @@ -42,7 +42,6 @@ class DistinctProcessor : public ScanAndApplyFormulaUnitTransformer { virtual void updateModifiedProblem(Problem& prb) { - CALL("DistinctProcessor::updateModifiedProblem"); prb.invalidateProperty(); } }; diff --git a/Shell/EqResWithDeletion.cpp b/Shell/EqResWithDeletion.cpp index 4363d1576..bc45741bd 100644 --- a/Shell/EqResWithDeletion.cpp +++ b/Shell/EqResWithDeletion.cpp @@ -29,8 +29,6 @@ using namespace Kernel; void EqResWithDeletion::apply(Problem& prb) { - CALL("EqResWithDeletion::apply"); - if(apply(prb.units())) { prb.invalidateByRemoval(); } @@ -42,8 +40,6 @@ void EqResWithDeletion::apply(Problem& prb) */ bool EqResWithDeletion::apply(UnitList*& units) { - CALL("EqResWithDeletion::apply(UnitList*&)"); - bool modified = false; UnitList::DelIterator uit(units); @@ -67,8 +63,6 @@ bool EqResWithDeletion::apply(UnitList*& units) */ Clause* EqResWithDeletion::apply(Clause* cl) { - CALL("EqResWithDeletion::apply(Clause*)"); - //TODO: make the procedure linear time start_applying: @@ -118,8 +112,6 @@ TermList EqResWithDeletion::apply(unsigned var) bool EqResWithDeletion::scan(Literal* lit) { - CALL("EqResWithDeletion::scan(Literal*)"); - if(lit->isEquality() && lit->isNegative()) { TermList t0=*lit->nthArgument(0); TermList t1=*lit->nthArgument(1); diff --git a/Shell/EqualityProxy.cpp b/Shell/EqualityProxy.cpp index 4a1f7ddc7..8a7aaf307 100644 --- a/Shell/EqualityProxy.cpp +++ b/Shell/EqualityProxy.cpp @@ -45,7 +45,6 @@ using namespace Kernel; EqualityProxy::EqualityProxy(Options::EqualityProxy opt) : _opt(opt), _addedPred(0), _defUnit(0) { - CALL("EqualityProxy::EqualityProxy/1"); ASS(opt != Options::EqualityProxy::OFF); } // EqualityProxy::EqualityProxy @@ -57,8 +56,6 @@ EqualityProxy::EqualityProxy(Options::EqualityProxy opt) */ void EqualityProxy::apply(Problem& prb) { - CALL("EqualityProxy::apply(Problem&)"); - bool hadEquality = prb.hasEquality(); apply(prb.units()); @@ -88,8 +85,6 @@ void EqualityProxy::apply(Problem& prb) */ void EqualityProxy::apply(UnitList*& units) { - CALL("EqualityProxy::apply(UnitList*&)"); - UnitList::DelIterator uit(units); while (uit.hasNext()) { Unit* unit = uit.next(); @@ -112,8 +107,6 @@ void EqualityProxy::apply(UnitList*& units) */ void EqualityProxy::addLocalAxioms(UnitList*& units) { - CALL("EqualityProxy::addLocalAxioms"); - // reflexivity Stack lits; TermList sort = TermList(false, 0); @@ -143,8 +136,6 @@ void EqualityProxy::addLocalAxioms(UnitList*& units) */ void EqualityProxy::addAxioms(UnitList*& units) { - CALL("EqualityProxy::addAxioms"); - if (_opt == Options::EqualityProxy::RSTC) { addCongruenceAxioms(units); } @@ -161,7 +152,6 @@ void EqualityProxy::addAxioms(UnitList*& units) void EqualityProxy::getArgumentEqualityLiterals(unsigned cnt, LiteralStack& lits, Stack& vars1, Stack& vars2, OperatorType* symbolType) { - CALL("EqualityProxy::getArgumentEqualityLiterals"); ASS_EQ(cnt, symbolType->arity()); lits.reset(); @@ -196,8 +186,6 @@ void EqualityProxy::getArgumentEqualityLiterals(unsigned cnt, LiteralStack& lits */ void EqualityProxy::addCongruenceAxioms(UnitList*& units) { - CALL("EqualityProxy::addCongruenceAxioms"); - // This is Krystof Hoder's comment: // TODO: skip UPDR predicates!!! Stack vars1; @@ -247,8 +235,6 @@ void EqualityProxy::addCongruenceAxioms(UnitList*& units) */ Clause* EqualityProxy::apply(Clause* cl) { - CALL("EqualityProxy::apply(Clause*)"); - unsigned clen = cl->length(); Stack resLits(8); @@ -289,8 +275,6 @@ Clause* EqualityProxy::apply(Clause* cl) */ Literal* EqualityProxy::apply(Literal* lit) { - CALL("EqualityProxy::apply(Literal*)"); - if (!lit->isEquality()) { return lit; } @@ -309,8 +293,6 @@ Literal* EqualityProxy::apply(Literal* lit) */ unsigned EqualityProxy::getProxyPredicate() { - CALL("EqualityProxy::getProxyPredicate"); - if(_addedPred){ return _proxyPredicate; } unsigned newPred = env.signature->addFreshPredicate(3,"sQ","eqProxy"); @@ -353,8 +335,6 @@ unsigned EqualityProxy::getProxyPredicate() */ Clause* EqualityProxy::createEqProxyAxiom(const LiteralStack& literalStack) { - CALL("EqualityProxy::createEqProxyAxiom(const LiteralStack&,unsigned)"); - ASS(_defUnit); Clause* res = Clause::fromStack(literalStack, NonspecificInference1(InferenceRule::EQUALITY_PROXY_AXIOM2,_defUnit)); return res; @@ -368,8 +348,6 @@ Clause* EqualityProxy::createEqProxyAxiom(const LiteralStack& literalStack) */ Literal* EqualityProxy::makeProxyLiteral(bool polarity, TermList arg0, TermList arg1, TermList sort) { - CALL("EqualityProxy::makeProxyLiteral"); - unsigned pred = getProxyPredicate(); TermList args[] = {sort, arg0, arg1}; return Literal::create(pred, 3, polarity, false, args); diff --git a/Shell/EqualityProxyMono.cpp b/Shell/EqualityProxyMono.cpp index d71a99950..edc6be9c7 100644 --- a/Shell/EqualityProxyMono.cpp +++ b/Shell/EqualityProxyMono.cpp @@ -46,7 +46,6 @@ DHMap EqualityProxyMono::s_proxyPremises; EqualityProxyMono::EqualityProxyMono(Options::EqualityProxy opt) : _opt(opt) { - CALL("EqualityProxyMono::EqualityProxyMono/1"); ASS(opt != Options::EqualityProxy::OFF); } // EqualityProxy::EqualityProxy @@ -58,8 +57,6 @@ EqualityProxyMono::EqualityProxyMono(Options::EqualityProxy opt) */ void EqualityProxyMono::apply(Problem& prb) { - CALL("EqualityProxyMono::apply(Problem&)"); - bool hadEquality = prb.hasEquality(); apply(prb.units()); @@ -89,8 +86,6 @@ void EqualityProxyMono::apply(Problem& prb) */ void EqualityProxyMono::apply(UnitList*& units) { - CALL("EqualityProxyMono::apply(UnitList*&)"); - UnitList::DelIterator uit(units); while (uit.hasNext()) { Unit* unit = uit.next(); @@ -113,8 +108,6 @@ void EqualityProxyMono::apply(UnitList*& units) */ void EqualityProxyMono::addLocalAxioms(UnitList*& units, TermList sort) { - CALL("EqualityProxyMono::addLocalAxioms"); - // reflexivity Stack lits; lits.push(makeProxyLiteral(true,TermList(0,false),TermList(0,false), sort)); @@ -147,8 +140,6 @@ void EqualityProxyMono::addLocalAxioms(UnitList*& units, TermList sort) */ void EqualityProxyMono::addAxioms(UnitList*& units) { - CALL("EqualityProxyMono::addAxioms"); - // if we're adding congruence axioms, we need to add them before adding the local axioms. // Local axioms are added only for sorts on which equality is used, and the congruence axioms // may spread the equality use into new sorts @@ -171,7 +162,6 @@ void EqualityProxyMono::addAxioms(UnitList*& units) bool EqualityProxyMono::getArgumentEqualityLiterals(unsigned cnt, LiteralStack& lits, Stack& vars1, Stack& vars2, OperatorType* symbolType, bool skipSortsWithoutEquality) { - CALL("EqualityProxyMono::getArgumentEqualityLiterals"); ASS_EQ(cnt, symbolType->arity()); lits.reset(); @@ -203,8 +193,6 @@ bool EqualityProxyMono::getArgumentEqualityLiterals(unsigned cnt, LiteralStack& */ void EqualityProxyMono::addCongruenceAxioms(UnitList*& units) { - CALL("EqualityProxyMono::addCongruenceAxioms"); - // This is Krystof Hoder's comment: // TODO: skip UPDR predicates!!! Stack vars1; @@ -254,8 +242,6 @@ void EqualityProxyMono::addCongruenceAxioms(UnitList*& units) */ Clause* EqualityProxyMono::apply(Clause* cl) { - CALL("EqualityProxyMono::apply(Clause*)"); - unsigned clen = cl->length(); UnitStack proxyPremises; @@ -310,8 +296,6 @@ Clause* EqualityProxyMono::apply(Clause* cl) */ Literal* EqualityProxyMono::apply(Literal* lit) { - CALL("EqualityProxyMono::apply(Literal*)"); - if (!lit->isEquality()) { return lit; } @@ -328,7 +312,6 @@ Literal* EqualityProxyMono::apply(Literal* lit) */ bool EqualityProxyMono::haveProxyPredicate(TermList sort) const { - CALL("EqualityProxyMono::haveProxyPredicate"); return s_proxyPredicates.find(sort); } // haveProxyPredicate @@ -341,8 +324,6 @@ bool EqualityProxyMono::haveProxyPredicate(TermList sort) const */ unsigned EqualityProxyMono::getProxyPredicate(TermList sort) { - CALL("EqualityProxyMono::getProxyPredicate"); - unsigned pred; if (s_proxyPredicates.find(sort, pred)) { return pred; @@ -381,8 +362,6 @@ unsigned EqualityProxyMono::getProxyPredicate(TermList sort) */ Clause* EqualityProxyMono::createEqProxyAxiom(const LiteralStack& literalStack) { - CALL("EqualityProxyMono::createEqProxyAxiom(const LiteralStack&,unsigned)"); - DHSet sorts; UnitList* prems = 0; @@ -412,8 +391,6 @@ Clause* EqualityProxyMono::createEqProxyAxiom(const LiteralStack& literalStack) */ Literal* EqualityProxyMono::makeProxyLiteral(bool polarity, TermList arg0, TermList arg1, TermList sort) { - CALL("EqualityProxyMono::createProxyLiteral/4"); - unsigned pred = getProxyPredicate(sort); TermList args[] = {arg0, arg1}; return Literal::create(pred, 2, polarity, false, args); diff --git a/Shell/FOOLElimination.cpp b/Shell/FOOLElimination.cpp index af825f305..3baef770b 100644 --- a/Shell/FOOLElimination.cpp +++ b/Shell/FOOLElimination.cpp @@ -51,8 +51,6 @@ const char* FOOLElimination::MATCH_PREFIX = "mG"; FOOLElimination::FOOLElimination() : _defs(0), _higherOrder(0), _polymorphic(0) {} bool FOOLElimination::needsElimination(FormulaUnit* unit) { - CALL("FOOLElimination::needsElimination"); - /** * Be careful with the difference between FOOLElimination::needsElimination * and Property::_hasFOOL! @@ -96,8 +94,6 @@ bool FOOLElimination::needsElimination(FormulaUnit* unit) { } void FOOLElimination::apply(Problem& prb) { - CALL("FOOLElimination::apply(Problem*)"); - _higherOrder = prb.hasApp(); _polymorphic = prb.hasPolymorphicSym(); apply(prb.units()); @@ -106,8 +102,6 @@ void FOOLElimination::apply(Problem& prb) { } void FOOLElimination::apply(UnitList*& units) { - CALL("FOOLElimination::apply(UnitList*&)"); - UnitList::DelIterator us(units); while(us.hasNext()) { Unit* unit = us.next(); @@ -136,8 +130,6 @@ void FOOLElimination::apply(UnitList*& units) { } FormulaUnit* FOOLElimination::apply(FormulaUnit* unit) { - CALL("FOOLElimination::apply(FormulaUnit*)"); - if (!needsElimination(unit)) { return unit; } @@ -175,8 +167,6 @@ FormulaUnit* FOOLElimination::apply(FormulaUnit* unit) { } Formula* FOOLElimination::process(Formula* formula) { - CALL("FOOLElimination::process(Formula*)"); - if(env.options->cnfOnTheFly() != Options::CNFOnTheFly::EAGER && !_polymorphic){ LambdaElimination le = LambdaElimination(); @@ -321,8 +311,6 @@ Formula* FOOLElimination::process(Formula* formula) { } FormulaList* FOOLElimination::process(FormulaList* formulas) { - CALL ("FOOLElimination::process(FormulaList*)"); - FormulaList* res = FormulaList::empty(); FormulaList** ipt = &res; @@ -369,8 +357,6 @@ FormulaList* FOOLElimination::process(FormulaList* formulas) { * FOOL_TRUE all over the place. */ void FOOLElimination::process(TermList ts, Context context, TermList& termResult, Formula*& formulaResult) { - CALL("FOOLElimination::process(TermList ts, Context context, ...)"); - #if VDEBUG // A term can only be processed in a formula context if it has boolean sort // The opposite does not hold - a boolean term can stand in a term context @@ -403,7 +389,6 @@ void FOOLElimination::process(TermList ts, Context context, TermList& termResult * A shortcut of process(TermList, context) for TERM_CONTEXT. */ TermList FOOLElimination::process(TermList terms) { - CALL("FOOLElimination::process(TermList terms)"); TermList ts; Formula* dummy; process(terms, TERM_CONTEXT, ts, dummy); @@ -414,7 +399,6 @@ TermList FOOLElimination::process(TermList terms) { * A shortcut of process(TermList, context) for FORMULA_CONTEXT. */ Formula* FOOLElimination::processAsFormula(TermList terms) { - CALL("FOOLElimination::processAsFormula(TermList terms)"); Formula* formula = nullptr; TermList dummy; process(terms, FORMULA_CONTEXT, dummy, formula); @@ -437,8 +421,6 @@ Formula* FOOLElimination::processAsFormula(TermList terms) { * subterms and we don't have to further process it. */ void FOOLElimination::process(Term* term, Context context, TermList& termResult, Formula*& formulaResult) { - CALL("FOOLElimination::process(Term* term, Context context, ...)"); - // collect free variables of the term and their sorts // WARNING, this list is leaked in all cases. Sometimes, // it becomes the quantified variables of a formula, @@ -891,8 +873,6 @@ void FOOLElimination::process(Term* term, Context context, TermList& termResult, * A shortcut of process(Term*, context) for TERM_CONTEXT. */ TermList FOOLElimination::process(Term* term) { - CALL("FOOLElimination::process(Term* term)"); - TermList termList; Formula* dummy; @@ -905,8 +885,6 @@ TermList FOOLElimination::process(Term* term) { * A shortcut of process(Term*, context) for FORMULA_CONTEXT. */ Formula* FOOLElimination::processAsFormula(Term* term) { - CALL("FOOLElimination::processAsFormula(Term* term)"); - Formula* formula = nullptr; TermList dummy; @@ -922,8 +900,6 @@ Formula* FOOLElimination::processAsFormula(Term* term) { */ Formula* FOOLElimination::buildEq(Context context, Formula* lhsFormula, Formula* rhsFormula, TermList lhsTerm, TermList rhsTerm, TermList termSort) { - CALL("FOOLElimination::buildEq"); - if (context == FORMULA_CONTEXT) { // build equivalence return new BinaryFormula(IFF, lhsFormula, rhsFormula); @@ -941,8 +917,6 @@ Formula* FOOLElimination::buildEq(Context context, Formula* lhsFormula, Formula* */ void FOOLElimination::buildApplication(unsigned symbol, Context context, TermStack& vars, TermList& functionApplication, Formula*& predicateApplication) { - CALL("FOOLElimination::buildApplication"); - if (context == FORMULA_CONTEXT) { predicateApplication = new AtomicFormula(Literal::create(symbol, vars.size(), true, false, vars.begin())); } else { @@ -957,8 +931,6 @@ void FOOLElimination::buildApplication(unsigned symbol, Context context, TermSta void FOOLElimination::collectSorts(VList* vars, TermStack& typeVars, TermStack& termVars, TermStack& allVars, TermStack& termVarSorts) { - CALL("FOOLElimination::collectSorts"); - VList::Iterator fvi(vars); while (fvi.hasNext()) { unsigned var = fvi.next(); @@ -986,8 +958,6 @@ void FOOLElimination::collectSorts(VList* vars, TermStack& typeVars, * doesn't have FOOL subterms. */ void FOOLElimination::addDefinition(FormulaUnit* def) { - CALL("FOOLElimination::addDefinition"); - ASS_REP(!needsElimination(def), def->toString()); _defs = new UnitList(def, _defs); @@ -1007,8 +977,6 @@ Formula* FOOLElimination::toEquality(TermList booleanTerm) { unsigned FOOLElimination::introduceFreshSymbol(Context context, const char* prefix, TermStack sorts, TermList resultSort, unsigned typeArgsArity) { - CALL("FOOLElimination::introduceFreshSymbol"); - unsigned arity = (unsigned)sorts.size(); OperatorType* type; if (context == FORMULA_CONTEXT) { @@ -1042,8 +1010,6 @@ unsigned FOOLElimination::introduceFreshSymbol(Context context, const char* pref } void FOOLElimination::reportProcessed(vstring inputRepr, vstring outputRepr) { - CALL("FOOLElimination::reportProcessed"); - if (inputRepr != outputRepr) { /** * If show_fool is set to off, the string representations of the input diff --git a/Shell/Flattening.cpp b/Shell/Flattening.cpp index b2645e5b0..08eda8feb 100644 --- a/Shell/Flattening.cpp +++ b/Shell/Flattening.cpp @@ -15,7 +15,6 @@ */ #include "Debug/RuntimeStatistics.hpp" -#include "Debug/Tracer.hpp" #include "Kernel/Inference.hpp" #include "Kernel/FormulaUnit.hpp" @@ -36,8 +35,6 @@ namespace Shell */ Formula* Flattening::getFlattennedNegation(Formula* f) { - CALL("Flattening::getFlattennedNegation"); - switch(f->connective()) { case NOT: return f->uarg(); @@ -61,7 +58,6 @@ Formula* Flattening::getFlattennedNegation(Formula* f) */ FormulaUnit* Flattening::flatten (FormulaUnit* unit) { - CALL("Flattening::flatten (Unit*)"); ASS(! unit->isClause()); Formula* f = unit->formula(); @@ -92,8 +88,6 @@ FormulaUnit* Flattening::flatten (FormulaUnit* unit) */ Formula* Flattening::innerFlatten (Formula* f) { - CALL("Flattening::innerFlatten(Formula*)"); - Connective con = f->connective(); switch (con) { case TRUE: @@ -214,8 +208,6 @@ Formula* Flattening::innerFlatten (Formula* f) Literal* Flattening::flatten(Literal* l) { - CALL("Flattening::flatten(Literal*)"); - if (l->shared()) { return l; } @@ -241,8 +233,6 @@ Literal* Flattening::flatten(Literal* l) TermList Flattening::flatten (TermList ts) { - CALL("Flattening::flatten(TermList)"); - if (ts.isVar()) { return ts; } @@ -373,7 +363,6 @@ TermList Flattening::flatten (TermList ts) FormulaList* Flattening::flatten (FormulaList* fs, Connective con) { - CALL("Flattening::flatten (FormulaList*...)"); ASS(con == OR || con == AND); #if 1 diff --git a/Shell/FunctionDefinition.cpp b/Shell/FunctionDefinition.cpp index 61f499531..0b5458df8 100644 --- a/Shell/FunctionDefinition.cpp +++ b/Shell/FunctionDefinition.cpp @@ -14,7 +14,6 @@ * @since 28/05/2004 Manchester */ -#include "Debug/Tracer.hpp" #include "Lib/Allocator.hpp" #include "Lib/DHMultiset.hpp" @@ -135,13 +134,10 @@ FunctionDefinition::FunctionDefinition () _removed(0), _processedProblem(0) { - CALL("FunctionDefinition::FunctionDefinition"); } // FunctionDefinition::FunctionDefinition void FunctionDefinition::removeUnusedDefinitions(Problem& prb, bool inHigherOrder) { - CALL("FunctionDefinition::removeUnusedDefinitions"); - if(removeUnusedDefinitions(prb.units(), &prb, inHigherOrder)) { prb.invalidateByRemoval(); } @@ -159,8 +155,6 @@ void FunctionDefinition::removeUnusedDefinitions(Problem& prb, bool inHigherOrde */ bool FunctionDefinition::removeUnusedDefinitions(UnitList*& units, Problem* prb, bool inHigherOrder) { - CALL("FunctionDefinition::removeUnusedDefinitions"); - unsigned funs=env.signature->functions(); Stack defStack; @@ -242,8 +236,6 @@ bool FunctionDefinition::removeUnusedDefinitions(UnitList*& units, Problem* prb, void FunctionDefinition::removeAllDefinitions(Problem& prb, bool inHigherOrder) { - CALL("FunctionDefinition::removeAllDefinitions(Problem&)"); - ScopedLet prbLet(_processedProblem, &prb); if(removeAllDefinitions(prb.units(),inHigherOrder)) { prb.invalidateByRemoval(); @@ -251,7 +243,6 @@ void FunctionDefinition::removeAllDefinitions(Problem& prb, bool inHigherOrder) } void FunctionDefinition::reverse(Def* def){ - CALL("FunctionDefinition::reverse"); ASS(def->twoConstDef); Term* temp = def->lhs; def->lhs = def->rhs; @@ -265,8 +256,6 @@ void FunctionDefinition::reverse(Def* def){ */ bool FunctionDefinition::removeAllDefinitions(UnitList*& units, bool inHigherOrder) { - CALL("FunctionDefinition::removeAllDefinitions"); - UnitList::DelIterator scanIterator(units); while(scanIterator.hasNext()) { Clause* cl=static_cast(scanIterator.next()); @@ -391,8 +380,6 @@ bool FunctionDefinition::removeAllDefinitions(UnitList*& units, bool inHigherOrd void FunctionDefinition::checkDefinitions(Def* def0) { - CALL("FunctionDefinition::unfoldDefinition"); - TermList t=TermList(def0->lhs); //Next argument of the current-level term to be processed. @@ -491,7 +478,6 @@ void FunctionDefinition::checkDefinitions(Def* def0) */ void FunctionDefinition::assignArgOccursData(Def* updDef) { - CALL("FunctionDefinition::assignArgOccursData"); ASS(!updDef->argOccurs); if(!updDef->lhs->arity()) { @@ -565,8 +551,6 @@ typedef DHMap UnfoldedSet; Term* FunctionDefinition::applyDefinitions(Literal* lit, Stack* usedDefs) { - CALL("FunctionDefinition::applyDefinitions"); - //cout << "applying definitions to " + lit->toString() << endl; if (env.options->showPreprocessing()) { @@ -722,8 +706,6 @@ Term* FunctionDefinition::applyDefinitions(Literal* lit, Stack* usedDefs) Clause* FunctionDefinition::applyDefinitions(Clause* cl) { - CALL("FunctionDefinition::applyDefinitions(Clause*)") - unsigned clen=cl->length(); static Stack usedDefs(8); @@ -766,8 +748,6 @@ Clause* FunctionDefinition::applyDefinitions(Clause* cl) */ FunctionDefinition::~FunctionDefinition () { - CALL("FunctionDefinition::~FunctionDefinition"); - Fn2DefMap::Iterator dit(_defs); while(dit.hasNext()) { delete dit.next(); @@ -782,7 +762,6 @@ FunctionDefinition::~FunctionDefinition () FunctionDefinition::Def* FunctionDefinition::isFunctionDefinition (Unit& unit, bool inHigherOrder) { - CALL("FunctionDefinition::isFunctionDefinition(const Unit&)"); if(unit.derivedFromGoal() && env.options->ignoreConjectureInPreprocessing()){ return 0; } @@ -803,8 +782,6 @@ FunctionDefinition::isFunctionDefinition (Unit& unit, bool inHigherOrder) FunctionDefinition::Def* FunctionDefinition::isFunctionDefinition (Clause* clause, bool inHigherOrder) { - CALL("FunctionDefinition::isFunctionDefinition(Clause*)"); - if (clause->length() != 1) { return 0; } @@ -818,8 +795,6 @@ FunctionDefinition::isFunctionDefinition (Clause* clause, bool inHigherOrder) FunctionDefinition::Def* FunctionDefinition::isFunctionDefinition (Literal* lit, bool inHigherOrder) { - CALL("FunctionDefinition::isFunctionDefinition(const Literal*)"); - if (! lit->isPositive() || ! lit->isEquality() || ! lit->shared()) { @@ -866,8 +841,6 @@ FunctionDefinition::isFunctionDefinition (Literal* lit, bool inHigherOrder) FunctionDefinition::Def* FunctionDefinition::defines (Term* lhs, Term* rhs, bool inHigherOrder) { - CALL("FunctionDefinition::defines"); - if(!lhs->shared() || !rhs->shared()) { return 0; } @@ -961,8 +934,6 @@ FunctionDefinition::defines (Term* lhs, Term* rhs, bool inHigherOrder) */ bool FunctionDefinition::occurs (unsigned f, Term& t) { - CALL ("FunctionDefinition::occurs"); - TermFunIterator funs(&t); while (funs.hasNext()) { if (f == funs.next()) { @@ -983,8 +954,6 @@ bool FunctionDefinition::occurs (unsigned f, Term& t) FunctionDefinition::Def* FunctionDefinition::isFunctionDefinition (FormulaUnit& unit, bool inHigherOrder) { - CALL ("Definition::isFunctionDefinition(FormulaUnit&)" ); - Formula* f = unit.formula(); // skip all universal quantifiers in front of the formula while (f->connective() == FORALL) { diff --git a/Shell/GeneralSplitting.cpp b/Shell/GeneralSplitting.cpp index 6f519cf51..67c2d663c 100644 --- a/Shell/GeneralSplitting.cpp +++ b/Shell/GeneralSplitting.cpp @@ -39,7 +39,6 @@ using namespace Kernel; void GeneralSplitting::apply(Problem& prb) { - CALL("GeneralSplitting::apply(Problem&)"); if(apply(prb.units())) { prb.invalidateProperty(); } @@ -50,8 +49,6 @@ void GeneralSplitting::apply(Problem& prb) */ bool GeneralSplitting::apply(UnitList*& units) { - CALL("GeneralSplitting::apply(UnitList*&)"); - bool modified = false; UnitList* splitRes=0; @@ -81,8 +78,6 @@ bool GeneralSplitting::apply(UnitList*& units) */ bool GeneralSplitting::apply(ClauseList*& clauses) { - CALL("GeneralSplitting::apply(UnitList*&)"); - bool modified = false; UnitList* splitRes=0; @@ -116,8 +111,6 @@ bool GeneralSplitting::apply(ClauseList*& clauses) */ bool GeneralSplitting::apply(Clause*& cl, UnitList*& resultStack) { - CALL("GeneralSplitting::apply"); - unsigned clen=cl->length(); if(clen<=1) { return false; diff --git a/Shell/GoalGuessing.cpp b/Shell/GoalGuessing.cpp index 07a42ccd8..1e22be610 100644 --- a/Shell/GoalGuessing.cpp +++ b/Shell/GoalGuessing.cpp @@ -35,8 +35,6 @@ namespace Shell void GoalGuessing::apply(Problem& prb) { - CALL("GoalGuessing::apply(Problem&)"); - _lookInside = env.options->guessTheGoal() != Options::GoalGuess::POSITION; _checkTop = env.options->guessTheGoal() == Options::GoalGuess::EXISTS_TOP || env.options->guessTheGoal() == Options::GoalGuess::EXISTS_ALL; _checkSymbols = env.options->guessTheGoal() == Options::GoalGuess::EXISTS_SYM || env.options->guessTheGoal() == Options::GoalGuess::EXISTS_ALL; @@ -55,8 +53,6 @@ void GoalGuessing::apply(Problem& prb) bool GoalGuessing::apply(UnitList*& units) { - CALL("GoalGuessing::apply(UnitList*& units)"); - bool modified = false; UnitList::Iterator uit(units); @@ -86,8 +82,6 @@ bool GoalGuessing::apply(UnitList*& units) bool GoalGuessing::apply(Clause* cl) { - CALL("GoalGuessing::apply(Clause* cl)"); - if(cl->isPureTheoryDescendant()){ return false; } unsigned clen = cl->length(); @@ -101,8 +95,6 @@ bool GoalGuessing::apply(Clause* cl) } bool GoalGuessing::apply(FormulaUnit* fu) { - CALL("GoalGuessing::apply(FormulaUnit* fu)"); - bool looksLikeGoal = false; // existential quantification at the top-level is conjecture-like @@ -127,8 +119,6 @@ bool GoalGuessing::apply(FormulaUnit* fu) bool GoalGuessing::apply(Literal* lit) { - CALL("GoalGuessing::apply(Literal* lit)"); - if(!_checkSymbols){ return false; } //if(lit->isSpecial()){ return false; } diff --git a/Shell/InequalitySplitting.cpp b/Shell/InequalitySplitting.cpp index 876412672..22c20d023 100644 --- a/Shell/InequalitySplitting.cpp +++ b/Shell/InequalitySplitting.cpp @@ -50,8 +50,6 @@ InequalitySplitting::InequalitySplitting(const Options& opt) void InequalitySplitting::perform(Problem& prb) { - CALL("InequalitySplitting::perform"); - _appify = prb.hasApp(); if(perform(prb.units())) { prb.invalidateByRemoval(); @@ -60,8 +58,6 @@ void InequalitySplitting::perform(Problem& prb) bool InequalitySplitting::perform(UnitList*& units) { - CALL("InequalitySplitting::perform"); - bool modified = false; UnitList::DelIterator uit(units); @@ -84,7 +80,6 @@ bool InequalitySplitting::perform(UnitList*& units) Clause* InequalitySplitting::trySplitClause(Clause* cl) { - CALL("InequalitySplitting::trySplitClause"); ASS(cl); unsigned clen=cl->length(); @@ -146,7 +141,6 @@ Clause* InequalitySplitting::trySplitClause(Clause* cl) Literal* InequalitySplitting::splitLiteral(Literal* lit, UnitInputType inpType, Clause*& premise) { - CALL("InequalitySplitting::splitLiteral"); ASS(isSplittable(lit)); TermList srt = SortHelper::getEqualityArgumentSort(lit); @@ -217,8 +211,6 @@ Literal* InequalitySplitting::splitLiteral(Literal* lit, UnitInputType inpType, bool InequalitySplitting::isSplittable(Literal* lit) { - CALL("InequalitySplitting::isSplittable"); - return lit->isEquality() && lit->isNegative() && (isSplittableEqualitySide(*lit->nthArgument(0)) || isSplittableEqualitySide(*lit->nthArgument(1))); @@ -231,8 +223,6 @@ bool InequalitySplitting::isSplittableEqualitySide(TermList t) Literal* InequalitySplitting::makeNameLiteral(unsigned predNum, TermList arg, bool polarity, TermStack vars) { - CALL("InequalitySplitting::makeNameLiteral"); - if(!_appify){ vars.push(arg); return Literal::create(predNum, vars.size(), polarity, false, vars.begin()); diff --git a/Shell/InterpolantMinimizer.cpp b/Shell/InterpolantMinimizer.cpp index 082c53e30..59638388d 100644 --- a/Shell/InterpolantMinimizer.cpp +++ b/Shell/InterpolantMinimizer.cpp @@ -30,7 +30,6 @@ namespace Shell std::unordered_map InterpolantMinimizer::computeSplittingFunction(Kernel::Unit* refutation, UnitWeight weightFunction) { - CALL("InterpolantMinimizer::computeSplittingFunction"); BYPASSING_ALLOCATOR; using namespace z3; @@ -195,8 +194,6 @@ namespace Shell void InterpolantMinimizer::analyzeLocalProof(Kernel::Unit *refutation) { BYPASSING_ALLOCATOR; - CALL("InterpolantMinimizer::analyzeLocalProof"); - // print statistics on grey area analyzeGreyAreas(refutation); @@ -264,8 +261,6 @@ namespace Shell */ void InterpolantMinimizer::analyzeGreyAreas(Kernel::Unit* refutation) { - CALL("InterpolantMinimizer::analyzeGreyArea"); - int number_red = 0; int number_blue = 0; int number_grey = 0; diff --git a/Shell/Interpolants.cpp b/Shell/Interpolants.cpp index ce62c8595..c8d832ef4 100644 --- a/Shell/Interpolants.cpp +++ b/Shell/Interpolants.cpp @@ -71,8 +71,6 @@ namespace Shell void Interpolants::removeTheoryInferences(Unit* refutation) { BYPASSING_ALLOCATOR; - CALL("Interpolants::removeTheoryInferences"); - ProofIteratorPostOrder it(refutation); while (it.hasNext()) // traverse the proof in depth-first post order { @@ -143,8 +141,6 @@ namespace Shell Formula* Interpolants::getInterpolant(Unit *refutation, UnitWeight weightFunction) { BYPASSING_ALLOCATOR; - CALL("Interpolants::getInterpolant"); - /* * compute coloring for the inferences, i.e. compute splitting function in the words of the thesis */ @@ -178,8 +174,6 @@ namespace Shell */ Interpolants::SubproofsUnionFind Interpolants::computeSubproofs(Unit* refutation, const SplittingFunction& splittingFunction) { - CALL("Interpolants::computeSubproofs"); - std::unordered_map unitsToRepresentative; // maps each unit u1 (belonging to a red subproof) to the representative unit u2 of that subproof std::unordered_map unitsToSize; // needed for weighted quick-union: for each unit, counts number of elements rooted in that unit @@ -217,8 +211,6 @@ namespace Shell */ Interpolants::Boundary Interpolants::computeBoundary(Unit* refutation,const SplittingFunction& splittingFunction) { - CALL("Interpolants::computeBoundary"); - std::unordered_set inputNodes; // input is a blue premise of a red inference std::unordered_set outputNodes; // output is a red premise of a blue inference or a red refutation @@ -282,8 +274,6 @@ namespace Shell Formula* Interpolants::generateInterpolant(Kernel::Unit* refutation, const Boundary& boundary, const SplittingFunction& splittingFunction, const SubproofsUnionFind& unitsToRepresentative) { - CALL("Interpolants::generateInterpolant"); - const std::unordered_set& inputNodes = boundary.first; const std::unordered_set& outputNodes = boundary.second; @@ -296,12 +286,10 @@ namespace Shell InterpolantBuilder() : implCnt(0), lastCol(COLOR_LEFT), conjuncts(FormulaList::empty()), aside(nullptr) {} Formula* finiliseLeft() { - CALL("Interpolants::InterpolantBuilder::finiliseLeft"); return JunctionFormula::generalJunction(Connective::AND, conjuncts); } Formula* finiliseRight() { - CALL("Interpolants::InterpolantBuilder::finiliseRight"); Formula* antecedent = JunctionFormula::generalJunction(Connective::AND, conjuncts); implCnt++; @@ -310,7 +298,6 @@ namespace Shell } Formula* finalise() { - CALL("Interpolants::InterpolantBuilder::finalise"); if (lastCol == COLOR_LEFT) { return finiliseLeft(); } else { @@ -319,7 +306,6 @@ namespace Shell } void addLeft(Unit* u) { - CALL("Interpolants::InterpolantBuilder::addLeft"); // cout << "addLeft " << u->toString() << endl; if (lastCol != COLOR_LEFT) { @@ -333,7 +319,6 @@ namespace Shell } void addRight(Unit* u) { - CALL("Interpolants::InterpolantBuilder::addRight"); // cout << "addRight " << u->toString() << endl; if (lastCol != COLOR_RIGHT) { @@ -414,8 +399,6 @@ namespace Shell void Interpolants::removeConjectureNodesFromRefutation(Unit* refutation) { - CALL("Interpolants::removeConjectureNodesFromRefutation"); - Stack todo; DHSet seen; @@ -452,8 +435,6 @@ namespace Shell Unit* Interpolants::formulifyRefutation(Unit* refutation) { - CALL("Interpolants::formulifyRefutation"); - Stack todo; DHMap translate; // for caching results (we deal with a DAG in general), but also to distinguish the first call from the next @@ -530,8 +511,6 @@ namespace Shell */ std::unordered_map Interpolants::computeSplittingFunction(Kernel::Unit* refutation, UnitWeight weightFunction) { - CALL("Interpolants::computeSplittingFunction"); - std::unordered_map splittingFunction; ProofIteratorPostOrder it(refutation); @@ -608,8 +587,6 @@ namespace Shell double Interpolants::weightForUnit(Kernel::Unit* unit, UnitWeight weightFunction) { - CALL("Interpolants::weightForUnit"); - if (weightFunction == UnitWeight::VAMPIRE) { return unit->getWeight(); @@ -635,8 +612,6 @@ namespace Shell Kernel::Unit* Interpolants::root(const UnionFindMap& unitsToRepresentative, Unit* unit) { - CALL("Interpolants::root"); - Unit* root = unit; while (unitsToRepresentative.find(root) != unitsToRepresentative.end()) { @@ -649,8 +624,6 @@ namespace Shell bool Interpolants::find(UnionFindMap& unitsToRepresentative, Unit* unit1, Unit* unit2) { - CALL("Interpolants::find"); - return root(unitsToRepresentative, unit1) == root(unitsToRepresentative, unit2); } @@ -659,8 +632,6 @@ namespace Shell Unit* unit1, Unit* unit2) { - CALL("Interpolants::merge"); - ASS_NEQ(unit1, unit2); Unit* root1 = root(unitsToRepresentative, unit1); Unit* root2 = root(unitsToRepresentative, unit2); @@ -682,15 +653,11 @@ namespace Shell ProofIteratorBFSPreOrder::ProofIteratorBFSPreOrder(Unit* refutation) { - CALL("ProofIteratorBFSPreOrder::ProofIteratorBFSPreOrder"); - todo.push(refutation); } bool ProofIteratorBFSPreOrder::hasNext() { - CALL("ProofIteratorBFSPreOrder::hasNext"); - while (!todo.empty()) { if (visited.find(todo.front()) == visited.end()) @@ -711,8 +678,6 @@ namespace Shell */ Unit* ProofIteratorBFSPreOrder::next() { - CALL("ProofIteratorBFSPreOrder::next"); - while (!todo.empty()) { Unit* current = todo.front(); @@ -744,13 +709,11 @@ namespace Shell ProofIteratorPostOrder::ProofIteratorPostOrder(Unit* refutation) { - CALL("ProofIteratorPostOrder::ProofIteratorPostOrder"); todo.push(refutation); } bool ProofIteratorPostOrder::hasNext() { - CALL("ProofIteratorPostOrder::hasNext"); return !todo.empty(); } @@ -761,7 +724,6 @@ namespace Shell */ Unit* ProofIteratorPostOrder::next() { - CALL("ProofIteratorPostOrder::next"); while (!todo.empty()) { Unit* currentUnit = todo.top(); diff --git a/Shell/InterpretedNormalizer.cpp b/Shell/InterpretedNormalizer.cpp index 18a859b2f..eeecff13f 100644 --- a/Shell/InterpretedNormalizer.cpp +++ b/Shell/InterpretedNormalizer.cpp @@ -53,8 +53,6 @@ class InterpretedNormalizer::RoundingFunctionTranslator : public FunctionTransla RoundingFunctionTranslator(Interpretation origf, Interpretation newf, Interpretation roundf) { - CALL("InterpretedNormalizer::RoundingFunctionTranslator::RoundingFunctionTranslator"); - _origFun = env.signature->getInterpretingSymbol(origf); _newFun = env.signature->getInterpretingSymbol(newf); _roundingFun = env.signature->getInterpretingSymbol(roundf); @@ -63,7 +61,6 @@ class InterpretedNormalizer::RoundingFunctionTranslator : public FunctionTransla virtual TermList translate(Term* trm) { - CALL("InterpretedNormalizer::RoundingFunctionTranslator::translate"); ASS_EQ(trm->functor(), _origFun); TermList arg1 = trm->termArg(0); @@ -94,8 +91,6 @@ class InterpretedNormalizer::SuccessorTranslator : public FunctionTranslator SuccessorTranslator() { - CALL("InterpretedNormalizer::SuccessorTranslator::SuccessorTranslator"); - _succFun = env.signature->getInterpretingSymbol(Theory::INT_SUCCESSOR); _plusFun = env.signature->getInterpretingSymbol(Theory::INT_PLUS); _one = TermList(theory->representConstant(IntegerConstantType(1))); @@ -103,7 +98,6 @@ class InterpretedNormalizer::SuccessorTranslator : public FunctionTranslator virtual TermList translate(Term* trm) { - CALL("InterpretedNormalizer::SuccessorTranslator::translate"); ASS_EQ(trm->functor(), _succFun); TermList arg = trm->termArg(0); @@ -131,8 +125,6 @@ class InterpretedNormalizer::BinaryMinusTranslator : public FunctionTranslator BinaryMinusTranslator(Interpretation bMinus, Interpretation plus, Interpretation uMinus) { - CALL("InterpretedNormalizer::BinaryMinusTranslator::BinaryMinusTranslator"); - _bMinusFun = env.signature->getInterpretingSymbol(bMinus); _plusFun = env.signature->getInterpretingSymbol(plus); _uMinusFun = env.signature->getInterpretingSymbol(uMinus); @@ -140,7 +132,6 @@ class InterpretedNormalizer::BinaryMinusTranslator : public FunctionTranslator virtual TermList translate(Term* trm) { - CALL("InterpretedNormalizer::BinaryMinusTranslator::translate"); ASS_EQ(trm->functor(), _bMinusFun); TermList arg1 = trm->termArg(0); @@ -171,7 +162,6 @@ class InterpretedNormalizer::IneqTranslator IneqTranslator(Interpretation src, Interpretation tgt, bool swapArguments, bool reversePolarity) : _swapArguments(swapArguments), _reversePolarity(reversePolarity) { - CALL("InterpretedNormalizer::IneqTranslator::IneqTranslator"); _srcPred = env.signature->getInterpretingSymbol(src); _tgtPred = env.signature->getInterpretingSymbol(tgt); ASS_EQ(env.signature->predicateArity(_srcPred), 2); @@ -184,7 +174,6 @@ class InterpretedNormalizer::IneqTranslator Literal* apply(Literal* lit) { - CALL("InterpretedNormalizer::IneqTranslator::apply"); ASS_EQ(lit->functor(), _srcPred); TermList args[2] = { lit->termArg(0), lit->termArg(1) }; @@ -214,8 +203,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer : _ineqTransls(env.signature->predicates()), _fnTransfs(env.signature->functions()) { - CALL("InterpretedNormalizer::NLiteralTransformer::NLiteralTransformer"); - // from, to, swap, reverse_pol addIneqTransformer(Theory::INT_LESS_EQUAL, Theory::INT_LESS, true, true); addIneqTransformer(Theory::INT_GREATER, Theory::INT_LESS, true, false); @@ -248,8 +235,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer void apply(Literal* lit, bool& constantRes, Literal*& litRes, bool& boolRes) { - CALL("InterpretedNormalizer::NLiteralTransformer::apply"); - if (!lit->isEquality() && theory->isInterpretedPredicate(lit->functor())) { Interpretation itp = theory->interpretPredicate(lit); @@ -276,8 +261,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer TermList transformSubterm(TermList trm) override { - CALL("InterpretedNormalizer::NLiteralTransformer::transformSubterm"); - // sorts can never contain interpreted functions // this is a stopgap solution until PR that changes how termTransformer works // is merged @@ -313,8 +296,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ void addMinusTransformer(Interpretation bMinus, Interpretation plus, Interpretation uMinus) { - CALL("InterpretedNormalizer::NLiteralTransformer::addMinusTransformer"); - if(!env.signature->haveInterpretingSymbol(bMinus)) { return; //the symbol to be transformed doesn't exist, so we don't need to worry } @@ -329,8 +310,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ void addSuccessorTransformer() { - CALL("InterpretedNormalizer::NLiteralTransformer::addSuccessorTransformer"); - if(!env.signature->haveInterpretingSymbol(Theory::INT_SUCCESSOR)) { return; //the symbol to be transformed doesn't exist, so we don't need to worry } @@ -345,8 +324,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ void addRoundingFunctionTransformer(Interpretation origF, Interpretation newF, Interpretation roundF) { - CALL("InterpretedNormalizer::NLiteralTransformer::addRoundingFunctionTransformer"); - if(!env.signature->haveInterpretingSymbol(origF)) { return; //the symbol to be transformed doesn't exist, so we don't need to worry } @@ -363,8 +340,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ void addIneqTransformer(Interpretation from, Interpretation to, bool swapArguments, bool reversePolarity) { - CALL("InterpretedNormalizer::NLiteralTransformer::addIneqTransformer"); - if(!env.signature->haveInterpretingSymbol(from)) { return; //the symbol to be transformed doesn't exist, so we don't need to worry } @@ -380,7 +355,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ FunctionTranslator* getFnTranslator(unsigned func) { - CALL("InterpretedNormalizer::NLiteralTransformer::addIneqTransformer"); if(_fnTransfs.size()<=func) { return 0; } return _fnTransfs[func].ptr(); } @@ -391,7 +365,6 @@ class InterpretedNormalizer::NLiteralTransformer : public TermTransformer */ IneqTranslator* getIneqTranslator(unsigned ineq) { - CALL("InterpretedNormalizer::NLiteralTransformer::getIneqTranslator"); if(_ineqTransls.size()<=ineq) { return 0; } return _ineqTransls[ineq].ptr(); } @@ -418,8 +391,6 @@ class InterpretedNormalizer::NFormulaTransformer : public FormulaTransformer */ virtual Formula* applyLiteral(Formula* f) { - CALL("InterpretedNormalizer::NFormulaTransformer::applyLiteral"); - Literal* lit = f->literal(); bool isConst; Literal* newLit; @@ -449,22 +420,15 @@ Formula* InterpretedNormalizer::NLiteralTransformer::transform(Formula* f) InterpretedNormalizer::InterpretedNormalizer() : _litTransf(new NLiteralTransformer()) { - CALL("InterpretedNormalizer::InterpretedNormalizer"); - - } InterpretedNormalizer::~InterpretedNormalizer() { - CALL("InterpretedNormalizer::~InterpretedNormalizer"); - delete _litTransf; } void InterpretedNormalizer::apply(Problem& prb) { - CALL("InterpretedNormalizer::apply(Problem&)"); - if(apply(prb.units())) { prb.invalidateByRemoval(); } @@ -476,8 +440,6 @@ void InterpretedNormalizer::apply(Problem& prb) */ bool InterpretedNormalizer::apply(UnitList*& units) { - CALL("InterpretedNormalizer::apply(UnitList*& units)"); - NFormulaTransformer ftransf(_litTransf); FTFormulaUnitTransformer futransf(InferenceRule::THEORY_NORMALIZATION, ftransf); @@ -513,8 +475,6 @@ bool InterpretedNormalizer::apply(UnitList*& units) Clause* InterpretedNormalizer::apply(Clause* cl) { - CALL("InterpretedNormalizer::apply(Clause* cl)"); - static LiteralStack lits; lits.reset(); unsigned clen = cl->length(); @@ -556,8 +516,6 @@ Clause* InterpretedNormalizer::apply(Clause* cl) */ bool InterpretedNormalizer::isTrivialInterpretation(Interpretation itp) { - CALL("InterpretedNormalizer::isTrivialInterpretation"); - switch(itp) { case Theory::INT_IS_INT: case Theory::INT_IS_RAT: diff --git a/Shell/LaTeX.cpp b/Shell/LaTeX.cpp index 5d8115550..3c74a7f6d 100644 --- a/Shell/LaTeX.cpp +++ b/Shell/LaTeX.cpp @@ -19,7 +19,6 @@ #include "Options.hpp" #include "LaTeX.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Environment.hpp" #include "Lib/Exception.hpp" @@ -96,8 +95,6 @@ vstring LaTeX::footer() */ vstring LaTeX::refutationToString(Unit* ref) { - CALL("LaTeX::refutationToString(Unit* ref)"); - vstring res = header(); Stack outKernel; @@ -164,8 +161,6 @@ vstring LaTeX::refutationToString(Unit* ref) vstring LaTeX::toString(Unit* u) { - CALL("LaTeX::toString(Unit* u)"); - if(u->isClause()) { return toString(static_cast(u)); } else { @@ -193,8 +188,6 @@ vstring replaceNeg(vstring s) */ vstring LaTeX::toString (Formula* f) const { - CALL("LaTeX::toString(Formula* f)"); - static vstring names [] = { "", " \\Vand ", " \\Vor ", " \\Vimp ", " \\Viff ", " \\Vxor ", "\\neg ", "\\forall ", "\\exists ", "\bot", "\top", "", ""}; @@ -267,8 +260,6 @@ vstring LaTeX::toString (Formula* f) const */ vstring LaTeX::toString (Formula* f, Connective outer) const { - CALL("LaTeX::toString (Formula* f, Connective outer)"); - return f->parenthesesRequired(outer) ? vstring("(") + toString(f) + ")" : toString(f); @@ -282,8 +273,6 @@ vstring LaTeX::toString (Formula* f, Connective outer) const */ vstring LaTeX::toString (Clause* c) { - CALL("LaTeX::toString (Clause* c)"); - vstring result; if (c->isEmpty()) { @@ -323,8 +312,6 @@ vstring LaTeX::toString (Clause* c) */ vstring LaTeX::toString (Literal* l) const { - CALL("LaTeX::toString (Literal* l)"); - if (l->isEquality()) { if (l->isNegative()) { return toString(l->nthArgument(0),true) + " \\neq " + toString(l->nthArgument(1),true); @@ -378,8 +365,6 @@ vstring LaTeX::toString (Literal* l) const */ vstring LaTeX::symbolToString (unsigned num, bool pred) const { - CALL("LaTeX::symbolToString (unsigned num, bool pred)"); - vstring symbolName; // the name of this symbol, if any if(pred) { @@ -476,8 +461,6 @@ vstring LaTeX::symbolToString (unsigned num, bool pred) const */ vstring LaTeX::toString (TermList* terms,bool single) const { - CALL("LaTeX::toString (TermList* terms)"); - if (terms->isEmpty()) { return ""; } @@ -567,8 +550,6 @@ vstring LaTeX::getClauseLatexId(Unit* cs) vstring LaTeX::toStringAsInference(Unit* cs, InferenceStore::FullInference* inf) { - CALL("LaTeX::toStringAsInference(ClauseSpec,FullInference*)"); - vstring res("\\begin{VampireStep}\n[$"); bool hasParents=inf->premCnt; @@ -614,8 +595,6 @@ vstring LaTeX::toStringAsInference(Unit* cs, InferenceStore::FullInference* inf) */ vstring LaTeX::toStringAsInference(Unit* unit) { - CALL("LaTeX::toStringAsInference(Unit* unit)"); - Inference& inf = unit->inference(); vstring res("\\begin{VampireStep}\n[$"); @@ -661,8 +640,6 @@ vstring LaTeX::toStringAsInference(Unit* unit) /* vstring LaTeX::splittingToString(InferenceStore::SplittingRecord* sr) { - CALL("LaTeX::splittingToString"); - vstring res("[$"); res += getClauseLatexId(sr->premise); @@ -714,8 +691,6 @@ vstring LaTeX::splittingToString(InferenceStore::SplittingRecord* sr) */ vstring LaTeX::varToString (unsigned num) const { - CALL("LaTeX::varToString (unsigned num)"); - // if (v.toInt() < 0) { // row variable // return vstring("@_{") + Int::toString(-v.toInt()) + "}"; // } diff --git a/Shell/LambdaElimination.cpp b/Shell/LambdaElimination.cpp index 772781a02..656b373b6 100644 --- a/Shell/LambdaElimination.cpp +++ b/Shell/LambdaElimination.cpp @@ -56,8 +56,6 @@ typedef ApplicativeHelper AH; */ bool LambdaElimination::TermListComparator::lessThan(TermList t1, TermList t2) { - CALL("TermListComparator::lessThan"); - if(t1.tag()!=t2.tag()) { return t1.tag() < t2.tag(); } @@ -112,8 +110,6 @@ bool LambdaElimination::TermListComparator::lessThan(TermList t1, TermList t2) TermList LambdaElimination::elimLambda(Formula* formula) { - CALL("LambdaElimination::elimLambda(Formula*)"); - TermList appTerm; //The resulting term to be pushed onto _toBeProcessed TermList constant; //The HOL constant for various connectives @@ -240,8 +236,6 @@ TermList LambdaElimination::elimLambda(Formula* formula) TermList LambdaElimination::elimLambda(TermList term) { - CALL("LambdaElimination::elimLambda(TermList)"); - if(term.isVar()){ return term; } @@ -293,8 +287,6 @@ TermList LambdaElimination::elimLambda(TermList term) TermList LambdaElimination::elimLambda(Stack& vars, TermStack& sorts, TermList body, TermList sort) { - CALL("LambdaElimination::elimLambda(Stack& vars...)"); - TermList bodye = elimLambda(body); // Lambda elimination should not change the sort // of a term @@ -314,8 +306,6 @@ TermList LambdaElimination::elimLambda(Stack& vars, TermStack& sorts, TermList LambdaElimination::elimLambda(int var, TermList varSort, TermList body, TermList sort) { - CALL("LambdaElimination::elimLambda(int var...)"); - if(!body.isFreeVariable(var)){ return createKTerm(sort, varSort, body); } @@ -366,15 +356,11 @@ TermList LambdaElimination::elimLambda(int var, TermList varSort, TermList LambdaElimination::elimLambda(Term* lambdaTerm) { - CALL("LambdaElimination::elimLambda"); - return elimLambda(TermList(lambdaTerm)); } TermList LambdaElimination::createKTerm(TermList s1, TermList s2, TermList arg1) { - CALL("LambdaElimination::createKTerm"); - unsigned kcomb = env.signature->getCombinator(Signature::K_COMB); TermList res = TermList(Term::create2(kcomb, s1, s2)); return AH::createAppTerm(sortOf(res), res, arg1); @@ -383,8 +369,6 @@ TermList LambdaElimination::createKTerm(TermList s1, TermList s2, TermList arg1) TermList LambdaElimination::createSCorBTerm(TermList arg1, TermList arg1sort, TermList arg2, TermList arg2sort, Signature::Combinator comb) { - CALL("LambdaElimination::createSCorBTerm"); - TermList s1, s2, s3; unsigned cb = env.signature->getCombinator(comb); @@ -405,16 +389,12 @@ TermList LambdaElimination::createSCorBTerm(TermList arg1, TermList arg1sort, TermList LambdaElimination::sortOf(TermList t) { - CALL("LambdaElimination::sortOf"); - ASS(t.isTerm()); return SortHelper::getResultSort(t.term()); } void LambdaElimination::addCombinatorAxioms(Problem& prb) { - CALL("LambdaElimination::addCombinatorAxioms"); - auto srtOf = [] (TermList t) { ASS(t.isTerm()); return SortHelper::getResultSort(t.term()); @@ -489,8 +469,6 @@ void LambdaElimination::addCombinatorAxioms(Problem& prb) void LambdaElimination::addFunctionExtensionalityAxiom(Problem& prb) { - CALL("LambdaElimination::addFunctionExtensionalityAxiom"); - auto srtOf = [] (TermList t) { ASS(t.isTerm()); return SortHelper::getResultSort(t.term()); @@ -521,8 +499,6 @@ void LambdaElimination::addFunctionExtensionalityAxiom(Problem& prb) void LambdaElimination::addChoiceAxiom(Problem& prb) { - CALL("LambdaElimination::addChoiceAxiom"); - TermList alpha = TermList(0, false); TermList boolS = AtomicSort::boolSort(); TermList alphaBool = AtomicSort::arrowSort(alpha, AtomicSort::boolSort()); @@ -549,8 +525,6 @@ void LambdaElimination::addChoiceAxiom(Problem& prb) void LambdaElimination::addProxyAxioms(Problem& prb) { - CALL("LambdaElimination::addProxyAxioms"); - auto srtOf = [] (TermList t) { ASS(t.isTerm()); return SortHelper::getResultSort(t.term()); diff --git a/Shell/Lexer.cpp b/Shell/Lexer.cpp index e03280491..bf9523b74 100644 --- a/Shell/Lexer.cpp +++ b/Shell/Lexer.cpp @@ -15,7 +15,6 @@ */ #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Int.hpp" @@ -48,8 +47,6 @@ Lexer::Lexer (istream& in) */ bool Lexer::readNextChar () { - CALL("Lexer::readNextChar"); - if (_lookAheadChar) { _lastCharacter = _lookAheadChar; _lookAheadChar = 0; @@ -83,8 +80,6 @@ bool Lexer::readNextChar () */ void Lexer::readNumber (Token& token) { - CALL("Lexer::readNumber"); - if (_lastCharacter == '-') { saveLastChar(); readNextChar(); @@ -115,7 +110,6 @@ void Lexer::readNumber (Token& token) */ void Lexer::saveLastChar () { - CALL("Lexer::saveLastChar"); _charBuffer[_charCursor++] = (char)_lastCharacter; } // Lexer::saveLastChar @@ -126,8 +120,6 @@ void Lexer::saveLastChar () */ void Lexer::saveChar (int character) { - CALL("Lexer::saveChar"); - _charBuffer[_charCursor++] = (char)character; } // Lexer::saveChar @@ -139,8 +131,6 @@ void Lexer::saveChar (int character) */ void Lexer::saveTokenText (Token& token) { - CALL("Lexer::saveTokenText"); - _charBuffer[_charCursor] = 0; token.text = _charBuffer.content(); } // Lexer::saveTokenText @@ -152,8 +142,6 @@ void Lexer::saveTokenText (Token& token) */ void Lexer::readUnsignedInteger () { - CALL("TPTPLexer::readUnsignedInteger"); - saveLastChar(); while (readNextChar() && isDigit(_lastCharacter)) { @@ -215,7 +203,6 @@ void Lexer::readSequence (const char* cs) */ int Lexer::lookAhead() { - CALL("Lexer::lookAhead"); ASS(! _lookAheadChar); // cannot look ahead by two characters! _lookAheadChar = _stream.get(); diff --git a/Shell/LispLexer.cpp b/Shell/LispLexer.cpp index a7fb82b71..d4be4be4e 100644 --- a/Shell/LispLexer.cpp +++ b/Shell/LispLexer.cpp @@ -17,7 +17,6 @@ #include #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "Lib/Exception.hpp" @@ -42,8 +41,6 @@ LispLexer::LispLexer (istream& in) */ void LispLexer::skipWhiteSpacesAndComments () { - CALL("LispLexer::skipWhiteSpacesAndComments"); - bool comment = false; while (! _eof) { switch (_lastCharacter) { @@ -80,8 +77,6 @@ void LispLexer::skipWhiteSpacesAndComments () */ void LispLexer::readToken (Token& token) { - CALL("LispLexer::readToken"); - skipWhiteSpacesAndComments(); _charCursor = 0; @@ -139,8 +134,6 @@ void LispLexer::readToken (Token& token) */ void LispLexer::readName (Token& token) { - CALL("LispLexer::readName"); - saveLastChar(); while (readNextChar()) { @@ -177,8 +170,6 @@ void LispLexer::readName (Token& token) */ void LispLexer::readQuotedString(Token& token, char opening, char closing, char escapeChar) { - CALL("LispLexer::readQuotedString"); - bool escape=false; // Don't save this char so that the final string doesn't contain the quote symbol //saveLastChar(); diff --git a/Shell/LispParser.cpp b/Shell/LispParser.cpp index 09c73a1ae..e2c607bc1 100644 --- a/Shell/LispParser.cpp +++ b/Shell/LispParser.cpp @@ -37,8 +37,6 @@ LispParser::LispParser(LispLexer& lexer) */ LispParser::Expression* LispParser::parse() { - CALL("LispParser::parse/0"); - Expression* result = new Expression(LIST); parse(&result->list); return result; @@ -49,8 +47,6 @@ LispParser::Expression* LispParser::parse() // */ //void LispParser::parse(List** expr) //{ -// CALL("LispParser::parse/1"); -// // Token t; // for (;;) { // _lexer.readToken(t); @@ -99,8 +95,6 @@ LispParser::Expression* LispParser::parse() */ void LispParser::parse(List** expr0) { - CALL("LispParser::parse/1"); - static Stack stack; stack.reset(); @@ -165,8 +159,6 @@ void LispParser::parse(List** expr0) */ vstring LispParser::Expression::toString(bool outerParentheses) const { - CALL("LispParser::Expression::toString"); - switch (tag) { case ATOM: return str; @@ -197,8 +189,6 @@ vstring LispParser::Expression::toString(bool outerParentheses) const */ bool LispParser::Expression::get1Arg(vstring functionName, Expression*& arg) { - CALL("LispParser::Expression::get1Arg"); - if(!isList()) { return false; } @@ -224,8 +214,6 @@ bool LispParser::Expression::get1Arg(vstring functionName, Expression*& arg) */ bool LispParser::Expression::get2Args(vstring functionName, Expression*& arg1, Expression*& arg2) { - CALL("LispParser::Expression::get2Args"); - if(!isList()) { return false; } @@ -254,8 +242,6 @@ bool LispParser::Expression::get2Args(vstring functionName, Expression*& arg1, E */ bool LispParser::Expression::getPair(Expression*& el1, Expression*& el2) { - CALL("LispParser::Expression::getPair"); - if(!isList()) { return false; } @@ -276,8 +262,6 @@ bool LispParser::Expression::getPair(Expression*& el1, Expression*& el2) bool LispParser::Expression::getSingleton(Expression*& el) { - CALL("LispParser::Expression::getSingleton"); - if(!isList()) { return false; } @@ -320,8 +304,6 @@ void LispParser::Exception::cry(ostream& out) const void LispListReader::lispError(LExpr* expr, vstring reason) { - CALL("LispListReader::lispError"); - if(expr) { USER_ERROR(reason+": "+expr->toString()); } @@ -335,8 +317,6 @@ void LispListReader::lispError(LExpr* expr, vstring reason) */ void LispListReader::lispCurrError(vstring reason) { - CALL("LispListReader::lispCurrError"); - if(hasNext()) { lispError(peekAtNext(), reason); } @@ -347,7 +327,6 @@ void LispListReader::lispCurrError(vstring reason) LExpr* LispListReader::peekAtNext() { - CALL("LispListReader::peekAtNext"); ASS(hasNext()); return it.peekAtNext(); @@ -355,7 +334,6 @@ LExpr* LispListReader::peekAtNext() LExpr* LispListReader::readNext() { - CALL("LispListReader::readNext"); ASS(hasNext()); return it.next(); @@ -363,8 +341,6 @@ LExpr* LispListReader::readNext() bool LispListReader::tryReadAtom(vstring& atom) { - CALL("LispListReader::tryReadAtom"); - if(!hasNext()) { return false; } LExpr* next = peekAtNext(); @@ -378,8 +354,6 @@ bool LispListReader::tryReadAtom(vstring& atom) vstring LispListReader::readAtom() { - CALL("LispListReader::readAtom"); - vstring atm; if(!tryReadAtom(atm)) { lispCurrError("atom expected"); @@ -389,8 +363,6 @@ vstring LispListReader::readAtom() bool LispListReader::tryAcceptAtom(vstring atom) { - CALL("SMTLIBConcat::tryAcceptAtom"); - if(!hasNext()) { return false; } LExpr* next = peekAtNext(); @@ -403,8 +375,6 @@ bool LispListReader::tryAcceptAtom(vstring atom) void LispListReader::acceptAtom(vstring atom) { - CALL("SMTLIBConcat::acceptAtom"); - if(!tryAcceptAtom(atom)) { lispCurrError("atom \""+atom+"\" expected"); } @@ -412,8 +382,6 @@ void LispListReader::acceptAtom(vstring atom) bool LispListReader::tryReadListExpr(LExpr*& e) { - CALL("LispListReader::tryReadListExpr"); - if(!hasNext()) { return false; } LExpr* next = peekAtNext(); @@ -427,8 +395,6 @@ bool LispListReader::tryReadListExpr(LExpr*& e) LExpr* LispListReader::readListExpr() { - CALL("LispListReader::readListExpr"); - LExpr* list; if(!tryReadListExpr(list)) { lispCurrError("list expected"); @@ -438,8 +404,6 @@ LExpr* LispListReader::readListExpr() bool LispListReader::tryReadList(LExprList*& list) { - CALL("LispListReader::tryReadList"); - LExpr* lstExpr; if(tryReadListExpr(lstExpr)) { list = lstExpr->list; @@ -450,27 +414,21 @@ bool LispListReader::tryReadList(LExprList*& list) LExprList* LispListReader::readList() { - CALL("LispListReader::readList"); - return readListExpr()->list; } bool LispListReader::tryAcceptList() { - CALL("LispListReader::tryAcceptList"); LExprList* lst; return tryReadList(lst); } void LispListReader::acceptList() { - CALL("LispListReader::acceptList"); readList(); } void LispListReader::acceptEOL() { - CALL("LispListReader::acceptEOL"); - if(hasNext()) { lispCurrError(" expected"); } @@ -478,8 +436,6 @@ void LispListReader::acceptEOL() bool LispListReader::lookAheadAtom(vstring atom) { - CALL("LispListReader::lookAheadAtom"); - if(!hasNext()) { return false; } LExpr* next = peekAtNext(); return next->isAtom() && next->str==atom; @@ -487,8 +443,6 @@ bool LispListReader::lookAheadAtom(vstring atom) bool LispListReader::tryAcceptCurlyBrackets() { - CALL("LispListReader::tryAcceptCurlyBrackets"); - LExpr* next = peekAtNext(); if(!next->isAtom() || next->str!="{") { return false; diff --git a/Shell/LispParser.hpp b/Shell/LispParser.hpp index 700c9c451..6c40e367c 100644 --- a/Shell/LispParser.hpp +++ b/Shell/LispParser.hpp @@ -118,7 +118,6 @@ class LispListReader { public: explicit LispListReader(LExpr* e) : it(nullptr) { - CALL("LispListReader::LispListReader(LExpr*)"); if(!e->isList()) { lispError(e, "list expected"); } @@ -202,7 +201,6 @@ class LispListWriter LExprList* getList() const { - CALL("LispListWriter::getList"); ASS(!_destroyed); LExprList* res = 0; @@ -212,8 +210,6 @@ class LispListWriter LExpr* get() const { - CALL("LispListWriter::get"); - LExpr* res = new LExpr(LispParser::LIST); res->list = getList(); return res; diff --git a/Shell/NNF.cpp b/Shell/NNF.cpp index e095364ff..20ee6e29b 100644 --- a/Shell/NNF.cpp +++ b/Shell/NNF.cpp @@ -34,7 +34,6 @@ using namespace Shell; */ FormulaUnit* NNF::ennf(FormulaUnit* unit) { - CALL("NNF::ennf(Unit* u)"); ASS(! unit->isClause()); Formula* f = unit->formula(); @@ -64,7 +63,6 @@ FormulaUnit* NNF::ennf(FormulaUnit* unit) */ FormulaUnit* NNF::nnf(FormulaUnit* unit) { - CALL("NNF::nnf(Unit*)"); ASS(! unit->isClause()); Formula* f = unit->formula(); @@ -94,8 +92,6 @@ FormulaUnit* NNF::nnf(FormulaUnit* unit) */ Formula* NNF::ennf (Formula* f, bool polarity) { - CALL("NNF::ennf(Formula*...)"); - Connective c = f->connective(); switch (c) { case LITERAL: @@ -206,8 +202,6 @@ Formula* NNF::ennf (Formula* f, bool polarity) Literal* NNF::ennf(Literal* l) { - CALL("NNF::ennf(Literal*...)"); - if (l->shared()) { return l; } @@ -233,8 +227,6 @@ Literal* NNF::ennf(Literal* l) TermList NNF::ennf(TermList ts, bool polarity) { - CALL("NNF::ennf(TermList...)"); - if (ts.isVar()) { return ts; } @@ -392,8 +384,6 @@ TermList NNF::ennf(TermList ts, bool polarity) */ FormulaList* NNF::ennf (FormulaList* fs, bool polarity) { - CALL("NNF::ennf(FormulaList*...)"); - if (FormulaList::isEmpty(fs)) { return fs; } @@ -432,8 +422,6 @@ FormulaList* NNF::ennf (FormulaList* fs, bool polarity) */ Formula* NNF::nnf (Formula* f, bool polarity) { - CALL("NNF::nnf(Formula*...)"); - Connective c = f->connective(); switch (c) { case LITERAL: @@ -543,8 +531,6 @@ Formula* NNF::nnf (Formula* f, bool polarity) */ FormulaList* NNF::nnf (FormulaList* fs, bool polarity) { - CALL("NNF::nnf(FormulaList*...)"); - if (FormulaList::isEmpty(fs)) { return fs; } diff --git a/Shell/Naming.cpp b/Shell/Naming.cpp index c8173ae54..a02156b2a 100644 --- a/Shell/Naming.cpp +++ b/Shell/Naming.cpp @@ -64,7 +64,6 @@ Naming::Naming(int threshold, bool preserveEpr, bool appify) : * @since 14/07/2005 Tel-Aviv airport, changed to replace the unit */ FormulaUnit* Naming::apply(FormulaUnit* unit, UnitList*& defs) { - CALL("Naming::apply(Unit*)"); ASS(!unit->isClause()); ASS_REP(unit->formula()->freeVariables() == 0, *unit); ASS(!_varsInScope); //_varsInScope can be true only when traversing inside a formula @@ -111,8 +110,6 @@ FormulaUnit* Naming::apply(FormulaUnit* unit, UnitList*& defs) { } // Naming::apply Formula* Naming::apply_iter(Formula* top_f) { - CALL("Naming::apply_iter"); - TIME_TRACE("naming"); Stack todo_stack; @@ -749,8 +746,6 @@ Formula* Naming::apply_iter(Formula* top_f) { * @since 11/07/2005 flight Barcelona-Tel-Aviv */ Formula* Naming::apply_sub(Formula* f, Where where, int& pos, int& neg) { - CALL("Naming::apply_sub(Formula* ...)"); - switch (f->connective()) { case LITERAL: case BOOL_TERM: @@ -1077,8 +1072,6 @@ Formula* Naming::apply_sub(Formula* f, Where where, int& pos, int& neg) { * Return true if a definition for the formula @b f may be introduced */ bool Naming::canBeInDefinition(Formula* f, Where where) { - CALL("Naming::canBeInDefinition"); - if (!_preserveEpr) { return true; } @@ -1109,8 +1102,6 @@ bool Naming::canBeInDefinition(Formula* f, Where where) { } Literal* Naming::getDefinitionLiteral(Formula* f, VList* freeVars) { - CALL("Naming::getDefinitionLiteral"); - unsigned arity = VList::length(freeVars); static TermStack termVarSorts; @@ -1185,8 +1176,6 @@ Literal* Naming::getDefinitionLiteral(Formula* f, VList* freeVars) { * @since 01/07/2005 Manchester */ Formula* Naming::introduceDefinition(Formula* f, bool iff) { - CALL("Naming::introduceDefinition"); - ASS_NEQ(f->connective(), LITERAL); ASS_NEQ(f->connective(), NOT); @@ -1243,8 +1232,6 @@ Formula* Naming::introduceDefinition(Formula* f, bool iff) { */ FormulaList* Naming::apply_list(FormulaList* fs, Where where, int* results, int* negResults) { - CALL("Naming::apply_list(FormulaList*...)"); - if (FormulaList::isEmpty(fs)) { return fs; } diff --git a/Shell/NewCNF.cpp b/Shell/NewCNF.cpp index 954744174..84418e5c2 100644 --- a/Shell/NewCNF.cpp +++ b/Shell/NewCNF.cpp @@ -13,7 +13,6 @@ * @since 19/11/2015 Manchester */ -#include "Debug/Tracer.hpp" #include "Kernel/OperatorType.hpp" #include "Kernel/Clause.hpp" @@ -41,8 +40,6 @@ namespace Shell { void NewCNF::clausify(FormulaUnit* unit,Stack& output) { - CALL("NewCNF::clausify"); - _beingClausified = unit; Formula* f = unit->formula(); @@ -129,8 +126,6 @@ void NewCNF::clausify(FormulaUnit* unit,Stack& output) } void NewCNF::process(Literal* literal, Occurrences &occurrences) { - CALL("NewCNF::process(Literal*)"); - LOG2("process(Literal*)", literal->toString()); LOG2("occurrences.size", occurrences.size()); @@ -307,8 +302,6 @@ TermList NewCNF::findITEs(TermList ts, Stack &variables, Stack &matchVariables, Stack*> &matchConditions, Stack*> &matchBranches) { - CALL("NewCNF::findITEs"); - if (ts.isVar() || ts.term()->shared()) { return ts; } @@ -414,8 +407,6 @@ bool NewCNF::shouldInlineITE(unsigned iteCounter) { unsigned NewCNF::createFreshVariable(TermList sort) { - CALL("NewCNF::createFreshVariable"); - ensureHavingVarSorts(); _maxVar++; @@ -427,8 +418,6 @@ unsigned NewCNF::createFreshVariable(TermList sort) void NewCNF::createFreshVariableRenaming(unsigned oldVar, unsigned freshVar) { - CALL("NewCNF::createFreshVariableRenaming"); - ensureHavingVarSorts(); TermList sort; @@ -443,8 +432,6 @@ void NewCNF::createFreshVariableRenaming(unsigned oldVar, unsigned freshVar) void NewCNF::process(JunctionFormula *g, Occurrences &occurrences) { - CALL("NewCNF::process(JunctionFormula*)"); - LOG2("processJunction", g->toString()); LOG2("occurrences.size", occurrences.size()); @@ -477,8 +464,6 @@ void NewCNF::process(JunctionFormula *g, Occurrences &occurrences) void NewCNF::process(BinaryFormula* g, Occurrences &occurrences) { - CALL("NewCNF::process(BinaryFormula*)"); - LOG2("processBinary", g->toString()); LOG2("occurrences.size", occurrences.size()); @@ -504,8 +489,6 @@ void NewCNF::process(BinaryFormula* g, Occurrences &occurrences) void NewCNF::BindingStore::pushAndRememberWhileApplying(Binding b, BindingList* &lst) { - CALL("NewCNF::pushAndRememberWhileApplying"); - // turn b into a singleton substitution static Substitution subst; subst.bind(b.first,b.second); @@ -538,8 +521,6 @@ void NewCNF::BindingStore::pushAndRememberWhileApplying(Binding b, BindingList* void NewCNF::processBoolVar(SIGN sign, unsigned var, Occurrences &occurrences) { - CALL("NewCNF::processBoolVar"); - LOG2("processBoolVar", (sign == POSITIVE ? "X" : "~X") + Int::toString(var)); LOG2("occurrences.size", occurrences.size()); @@ -617,8 +598,6 @@ void NewCNF::processBoolVar(SIGN sign, unsigned var, Occurrences &occurrences) void NewCNF::processConstant(bool constant, Occurrences &occurrences) { - CALL("NewCNF::processConstant"); - while (occurrences.isNonEmpty()) { Occurrence occ = pop(occurrences); if (constant == (occ.sign() == POSITIVE)) { @@ -632,8 +611,6 @@ void NewCNF::processConstant(bool constant, Occurrences &occurrences) void NewCNF::processITE(Formula* condition, Formula* thenBranch, Formula* elseBranch, Occurrences &occurrences) { - CALL("NewCNF::processITE"); - enqueue(condition); enqueue(thenBranch); enqueue(elseBranch); @@ -650,7 +627,6 @@ void NewCNF::processITE(Formula* condition, Formula* thenBranch, Formula* elseBr void NewCNF::processMatch(Term::SpecialTermData *sd, Term *term, Occurrences &occurrences) { - CALL("NewCNF::processMatch"); auto matched = *term->nthArgument(0); for (unsigned int i = 1; i < term->arity(); i += 2) { @@ -676,8 +652,6 @@ void NewCNF::processMatch(Term::SpecialTermData *sd, Term *term, Occurrences &oc TermList NewCNF::eliminateLet(Term::SpecialTermData *sd, TermList contents) { - CALL("NewCNF::eliminateLet"); - ASS((sd->specialFunctor() == Term::SpecialFunctor::LET) || (sd->specialFunctor() == Term::SpecialFunctor::LET_TUPLE)); unsigned symbol; @@ -829,8 +803,6 @@ TermList NewCNF::eliminateLet(Term::SpecialTermData *sd, TermList contents) void NewCNF::processLet(Term::SpecialTermData* sd, TermList contents, Occurrences &occurrences) { - CALL("NewCNF::processLet"); - ASS((sd->specialFunctor() == Term::SpecialFunctor::LET) || (sd->specialFunctor() == Term::SpecialFunctor::LET_TUPLE)); TermList deletedContents = eliminateLet(sd, contents); // should be read "de-let-ed contents" @@ -843,8 +815,6 @@ void NewCNF::processLet(Term::SpecialTermData* sd, TermList contents, Occurrence TermList NewCNF::nameLetBinding(unsigned symbol, VList* bindingVariables, TermList binding, TermList contents) { - CALL("NewCNF::nameLetBinding"); - VList* bindingFreeVars = VList::empty(); FormulaVarIterator bfvi(&binding); while (bfvi.hasNext()) { @@ -934,8 +904,6 @@ TermList NewCNF::nameLetBinding(unsigned symbol, VList* bindingVariables, TermLi } TermList NewCNF::inlineLetBinding(unsigned symbol, VList* bindingVariables, TermList binding, TermList contents) { - CALL("NewCNF::inlineLetBinding(TermList)"); - ensureHavingVarSorts(); SymbolDefinitionInlining inlining(symbol, bindingVariables, binding, _maxVar); TermList inlinedContents = inlining.process(contents); @@ -951,8 +919,6 @@ TermList NewCNF::inlineLetBinding(unsigned symbol, VList* bindingVariables, Term VarSet* NewCNF::freeVars(Formula* g) { - CALL("NewCNF::freeVars"); - LOG2("freeVars for", g->toString()); VarSet* res; @@ -969,8 +935,6 @@ VarSet* NewCNF::freeVars(Formula* g) void NewCNF::ensureHavingVarSorts() { - CALL("NewCNF::ensureHavingVarSorts"); - if (!_collectedVarSorts) { SortHelper::collectVariableSorts(_beingClausified->formula(), _varSorts); _collectedVarSorts = true; @@ -987,8 +951,6 @@ void NewCNF::ensureHavingVarSorts() Term* NewCNF::createSkolemTerm(unsigned var, VarSet* free) { - CALL("NewCNF::createSkolemTerm"); - unsigned arity = free->size(); ensureHavingVarSorts(); @@ -1041,8 +1003,6 @@ Term* NewCNF::createSkolemTerm(unsigned var, VarSet* free) */ void NewCNF::skolemise(QuantifiedFormula* g, BindingList*& bindings, BindingList*& foolBindings) { - CALL("NewCNF::skolemise"); - BindingList* processedBindings; BindingList* processedFoolBindings; @@ -1125,8 +1085,6 @@ void NewCNF::skolemise(QuantifiedFormula* g, BindingList*& bindings, BindingList void NewCNF::process(QuantifiedFormula* g, Occurrences &occurrences) { - CALL("NewCNF::process(QuantifiedFormula*)"); - LOG2("processQuantified", g->toString()); LOG2("occurreces", occurrences.size()); @@ -1177,8 +1135,6 @@ void NewCNF::process(QuantifiedFormula* g, Occurrences &occurrences) void NewCNF::processBoolterm(TermList ts, Occurrences &occurrences) { - CALL("NewCNF::process(TermList)"); - if (ts.isVar()) { processBoolVar(POSITIVE, ts.var(), occurrences); return; @@ -1223,8 +1179,6 @@ void NewCNF::processBoolterm(TermList ts, Occurrences &occurrences) */ Literal* NewCNF::createNamingLiteral(Formula* f, VList* free) { - CALL("NewCNF::createNamingLiteral"); - unsigned length = VList::length(free); unsigned pred = env.signature->addNamePredicate(length); env.statistics->formulaNames++; @@ -1271,8 +1225,6 @@ Literal* NewCNF::createNamingLiteral(Formula* f, VList* free) */ void NewCNF::nameSubformula(Formula* g, Occurrences &occurrences) { - CALL("NewCNF::nameSubformula"); - LOG2("nameSubformula", g->toString()); LOG2("occurrences", occurrences.size()); @@ -1308,8 +1260,6 @@ void NewCNF::nameSubformula(Formula* g, Occurrences &occurrences) void NewCNF::process(Formula* g, Occurrences &occurrences) { - CALL("NewCNF::process"); - switch (g->connective()) { case AND: case OR: @@ -1352,8 +1302,6 @@ void NewCNF::process(Formula* g, Occurrences &occurrences) void NewCNF::toClauses(SPGenClause gc, Stack& output) { - CALL("NewCNF::toClauses"); - Stack variables; Stack skolems; @@ -1496,8 +1444,6 @@ void NewCNF::toClauses(SPGenClause gc, Stack& output) bool NewCNF::mapSubstitution(List* clause, Substitution subst, bool onlyFormulaLevel, List* &output) { - CALL("NewCNF::mapSubstitution"); - List::Iterator it(clause); while (it.hasNext()) { GenLit gl = it.next(); @@ -1532,8 +1478,6 @@ bool NewCNF::mapSubstitution(List* clause, Substitution subst, bool only Clause* NewCNF::toClause(SPGenClause gc) { - CALL("NewCNF::toClause"); - Substitution* subst; if (!_substitutionsByBindings.find(gc->bindings, subst)) { diff --git a/Shell/NewCNF.hpp b/Shell/NewCNF.hpp index b846ebd89..8bfb9452e 100644 --- a/Shell/NewCNF.hpp +++ b/Shell/NewCNF.hpp @@ -230,8 +230,6 @@ class NewCNF DHMap _literalsCache; DHMap _formulasCache; inline void pushLiteral(SPGenClause gc, GenLit gl) { - CALL("NewCNF::pushLiteral"); - if (formula(gl)->connective() == LITERAL) { /** * A generalised literal that is atomic have two signs, the one assigned @@ -367,8 +365,6 @@ class NewCNF } void replaceBy(Formula* f) { - CALL("Occurrences::replaceBy"); - Occurrences::Iterator occit(*this); bool negateOccurrenceSign = false; @@ -391,8 +387,6 @@ class NewCNF } void invert() { - CALL("Occurrences::invert"); - Occurrences::Iterator occit(*this); while (occit.hasNext()) { Occurrence occ = occit.next(); @@ -478,8 +472,6 @@ class NewCNF } void introduceExtendedGenClause(Occurrence occ, List* gls) { - CALL("NewCNF::introduceExtendedGenClause(Occurrence, List*)"); - SPGenClause gc = occ.gc; unsigned position = occ.position; @@ -545,8 +537,6 @@ class NewCNF } Occurrence pop(Occurrences &occurrences) { - CALL("NewCNF::pop"); - Occurrence occ = occurrences.pop(); occ.gc->valid = false; _genClauses.erase(occ.gc->iter); diff --git a/Shell/Normalisation.cpp b/Shell/Normalisation.cpp index d558b05cb..e4841ff60 100644 --- a/Shell/Normalisation.cpp +++ b/Shell/Normalisation.cpp @@ -40,8 +40,6 @@ Normalisation::Normalisation () */ void Normalisation::normalise(Problem& prb) { - CALL("Normalisation::normalise"); - UnitList* units = prb.units(); units = normalise(units); prb.units() = units; @@ -54,8 +52,6 @@ void Normalisation::normalise(Problem& prb) */ UnitList* Normalisation::normalise (UnitList* units) { - CALL("Normalisation::normalise (UnitList*"); - if (UnitList::isEmpty(units)) { return units; } @@ -88,8 +84,6 @@ UnitList* Normalisation::normalise (UnitList* units) */ void Normalisation::normalise (Unit* unit) { - CALL ("Normalisation::normalize(Unit*)"); - if (! unit->isClause()) { return; } @@ -126,8 +120,6 @@ void Normalisation::normalise (Unit* unit) * @since 03/06/2007 Manchester, changed to new data structures */ bool Normalisation::lessThan (Unit* u1, Unit* u2) { - CALL("Normalisation::lessThan (const Unit*...)"); - // the below code should be uncommented, it gives the best behavior // on the average switch (compare(static_cast(u1->inputType()),static_cast(u2->inputType()))) { @@ -187,8 +179,6 @@ bool Normalisation::lessThan(Clause* cl1, Clause* cl2) */ bool Normalisation::lessThan (Formula* f1, Formula* f2) { - CALL("Normalisation::lessThan (const Formula*...)"); - return compare(f1,f2) == LESS; } // Normalisation::lessThan @@ -204,8 +194,6 @@ bool Normalisation::lessThan (Formula* f1, Formula* f2) */ bool Normalisation::lessThan (Literal* l1, Literal* l2) { - CALL("Normalisation::lessThan (const Literal*...)"); - return compare(l1,l2) == LESS; } @@ -219,8 +207,6 @@ bool Normalisation::lessThan (Literal* l1, Literal* l2) */ Comparison Normalisation::compare (Formula* fm1, Formula* fm2) { - CALL("Normalisation::compare (const Formula*...)"); - SubformulaIterator sf1(fm1); SubformulaIterator sf2(fm2); @@ -287,8 +273,6 @@ Comparison Normalisation::compare (Formula* fm1, Formula* fm2) */ Comparison Normalisation::compare (Literal* l1, Literal* l2) { - CALL("Normalisation::compare (const Literal*...)"); - if (l1 == l2) { return EQUAL; } @@ -396,8 +380,6 @@ Comparison Normalisation::compare (Literal* l1, Literal* l2) */ Comparison Normalisation::compare(TermList ts1, TermList ts2) { - CALL("Normalisation::compare(TermList...)"); - // both non-empty if (ts1.isVar() && !ts2.isVar()) { return LESS; @@ -424,9 +406,6 @@ Comparison Normalisation::compare(TermList ts1, TermList ts2) */ Comparison Normalisation::compare(Term* t1, Term* t2) { - CALL("Normalisation::compare(const Term*...)"); - - if (t1 == t2) { return EQUAL; } diff --git a/Shell/Options.cpp b/Shell/Options.cpp index f98bfae78..1bb43f55b 100644 --- a/Shell/Options.cpp +++ b/Shell/Options.cpp @@ -24,7 +24,6 @@ #include "Forwards.hpp" -#include "Debug/Tracer.hpp" #include "Debug/Assertion.hpp" #include "Lib/VString.hpp" @@ -66,14 +65,11 @@ static const int COPY_SIZE = 128; Options::Options () { - CALL("Options::Options"); init(); } void Options::init() { - CALL("Options::init"); - //********************************************************************** //*********************** GLOBAL, for all modes *********************** //********************************************************************** @@ -2447,7 +2443,6 @@ void Options::init() void Options::copyValuesFrom(const Options& that) { - CALL("Options::copyValuesFrom"); //copy across the actual values in that VirtualIterator options = _lookup.values(); @@ -2464,16 +2459,12 @@ void Options::copyValuesFrom(const Options& that) } Options::Options(const Options& that) { - CALL("Options::Options(const Options& that)"); - init(); copyValuesFrom(that); } Options& Options::operator=(const Options& that) { - CALL("Options& Options::operator=(const Options& that)"); - if(this==&that) return *this; copyValuesFrom(that); return *this; @@ -2489,8 +2480,6 @@ Options& Options::operator=(const Options& that) */ void Options::set(const char* name,const char* value, bool longOpt) { - CALL ("Options::set/3"); - try { if((longOpt && !_lookup.findLong(name)->set(value)) || (!longOpt && !_lookup.findShort(name)->set(value))) { @@ -2544,12 +2533,10 @@ void Options::set(const char* name,const char* value, bool longOpt) */ void Options::set(const vstring& name,const vstring& value) { - CALL ("Options::set/2"); set(name.c_str(),value.c_str(),true); } // Options::set/2 bool Options::OptionHasValue::check(Property*p){ - CALL("Options::OptionHasValue::check"); AbstractOptionValue* opt = env.options->getOptionValueByName(option_value); ASS(opt); return opt->getStringOfActual()==value; @@ -2557,12 +2544,10 @@ bool Options::OptionHasValue::check(Property*p){ bool Options::HasTheories::actualCheck(Property*p) { - CALL("Options::HasTheories::actualCheck"); return (p->hasNumerals() || p->hasInterpretedOperations() || env.signature->hasTermAlgebras()); } bool Options::HasTheories::check(Property*p) { - CALL("Options::HasTheories::check"); // this was the condition used in Preprocess::preprocess guarding the addition of theory axioms return actualCheck(p); } @@ -2591,8 +2576,6 @@ Options::OptionProblemConstraintUP Options::saNotInstGen(){ */ vstring Options::includeFileName (const vstring& relativeName) { - CALL("Options::includeFileName"); - if (relativeName[0] == '/') { // absolute name return relativeName; } @@ -2644,8 +2627,6 @@ vstring Options::includeFileName (const vstring& relativeName) */ void Options::output (ostream& str) const { - CALL("Options::output"); - if(printAllTheoryAxioms()){ cout << "Sorry, not implemented yet!" << endl; @@ -2788,8 +2769,6 @@ void Options::output (ostream& str) const template bool Options::OptionValue::randomize(Property* prop){ - CALL("Options::OptionValue::randomize()"); - DArray* choices = nullptr; if(env.options->randomStrategy()==RandomStrategy::NOCHECK) prop=0; @@ -2822,7 +2801,6 @@ bool Options::OptionValue::randomize(Property* prop){ //TODO should not use cout, should use env.out template bool Options::OptionValue::checkConstraints(){ - CALL("Options::OptionValue::checkConstraints"); typename Lib::Stack>::RefIterator it(_constraints); while(it.hasNext()){ const OptionValueConstraintUP& con = it.next(); @@ -2862,8 +2840,6 @@ bool Options::OptionValue::checkConstraints(){ template bool Options::OptionValue::checkProblemConstraints(Property* prop){ - CALL("Options::OptionValue::checkProblemConstraints"); - Lib::Stack::RefIterator it(_prob_constraints); while(it.hasNext()){ OptionProblemConstraintUP& con = it.next(); @@ -2900,8 +2876,6 @@ Options::AbstractWrappedConstraintUP Options::OptionValue::is(OptionValueCons */ bool Options::RatioOptionValue::readRatio(const char* val, char separator) { - CALL("RatioOptionValue::readRatio"); - // search the string for ":" bool found = false; int colonIndex = 0; @@ -2949,8 +2923,6 @@ bool Options::RatioOptionValue::readRatio(const char* val, char separator) bool Options::NonGoalWeightOptionValue::setValue(const vstring& value) { - CALL("NonGoalWeightOptionValue::setValue"); - float newValue; if(!Int::stringToFloat(value.c_str(),newValue)) return false; @@ -2970,8 +2942,6 @@ bool Options::NonGoalWeightOptionValue::setValue(const vstring& value) bool Options::SelectionOptionValue::setValue(const vstring& value) { - CALL("SelectionOptionValue::setValue"); - int sel; if(!Int::stringToInt(value,sel)) return false; switch (sel) { @@ -3033,8 +3003,6 @@ bool Options::SelectionOptionValue::setValue(const vstring& value) bool Options::InputFileOptionValue::setValue(const vstring& value) { - CALL("InputFileOptionValue::setValue"); - actualValue=value; if(value.empty()) return true; @@ -3066,8 +3034,6 @@ bool Options::InputFileOptionValue::setValue(const vstring& value) bool Options::TimeLimitOptionValue::setValue(const vstring& value) { - CALL("Options::readTimeLimit"); - int length = value.size(); if (length == 0 || length >= COPY_SIZE) { USER_ERROR((vstring)"wrong value for time limit: " + value); @@ -3124,7 +3090,6 @@ bool Options::TimeLimitOptionValue::setValue(const vstring& value) void Options::randomizeStrategy(Property* prop) { - CALL("Options::randomizeStrategy"); if(_randomStrategy.actualValue==RandomStrategy::OFF) return; TIME_TRACE("random option generation"); @@ -3195,8 +3160,6 @@ void Options::randomizeStrategy(Property* prop) */ void Options::readOptionsString(vstring optionsString,bool assign) { - CALL("Options::readOptionsString"); - // repeatedly look for param=value while (optionsString != "") { size_t index1 = optionsString.find('='); @@ -3279,8 +3242,6 @@ void Options::readOptionsString(vstring optionsString,bool assign) */ void Options::readFromEncodedOptions (vstring testId) { - CALL("Options::readFromTestId"); - _normalize.actualValue = true; _testId.actualValue = testId; @@ -3348,8 +3309,6 @@ void Options::readFromEncodedOptions (vstring testId) void Options::setForcedOptionValues() { - CALL("Options::setForcedOptionValues"); - if(_forcedOptions.actualValue.empty()) return; readOptionsString(_forcedOptions.actualValue); } @@ -3359,8 +3318,6 @@ void Options::setForcedOptionValues() */ vstring Options::generateEncodedOptions() const { - CALL("Options::generateEncodedOptions"); - BYPASSING_ALLOCATOR; vostringstream res; //saturation algorithm @@ -3439,8 +3396,6 @@ vstring Options::generateEncodedOptions() const */ bool Options::complete(const Problem& prb) const { - CALL("Options::complete"); - if(prb.isHigherOrder()){ //safer for competition return false; @@ -3530,8 +3485,6 @@ bool Options::complete(const Problem& prb) const */ bool Options::completeForNNE() const { - CALL("Options::completeForNNE"); - // preprocessing if (_sineSelection.actualValue != SineSelection::OFF) return false; @@ -3558,8 +3511,6 @@ bool Options::completeForNNE() const */ bool Options::checkGlobalOptionConstraints(bool fail_early) { - CALL("Options::checkGlobalOptionsConstraints"); - //Check forbidden options readOptionsString(_forbiddenOptions.actualValue,false); @@ -3585,8 +3536,6 @@ bool Options::checkGlobalOptionConstraints(bool fail_early) **/ bool Options::checkProblemOptionConstraints(Property* prop, bool before_preprocessing, bool fail_early) { - CALL("Options::checkProblemOptionConstraints"); - bool result = true; VirtualIterator options = _lookup.values(); @@ -3619,9 +3568,6 @@ Lib::vvector parseCommaSeparatedList(vstring const& str) Lib::vvector Options::theorySplitQueueRatios() const { - CALL("Options::theorySplitQueueRatios"); - - auto inputRatios = parseCommaSeparatedList(_theorySplitQueueRatios.actualValue); // sanity checks @@ -3639,7 +3585,6 @@ Lib::vvector Options::theorySplitQueueRatios() const Lib::vvector Options::theorySplitQueueCutoffs() const { - CALL("Options::theorySplitQueueCutoffs"); // initialize cutoffs Lib::vvector cutoffs; @@ -3674,7 +3619,6 @@ Lib::vvector Options::theorySplitQueueCutoffs() const Lib::vvector Options::avatarSplitQueueRatios() const { - CALL("Options::avatarSplitQueueRatios"); Lib::vvector inputRatios = parseCommaSeparatedList(_avatarSplitQueueRatios.actualValue); // sanity checks @@ -3692,7 +3636,6 @@ Lib::vvector Options::avatarSplitQueueRatios() const Lib::vvector Options::avatarSplitQueueCutoffs() const { - CALL("Options::avatarSplitQueueCutoffs"); // initialize cutoffs and add float-max as last value auto cutoffs = parseCommaSeparatedList(_avatarSplitQueueCutoffs.actualValue); cutoffs.push_back(std::numeric_limits::max()); @@ -3713,7 +3656,6 @@ Lib::vvector Options::avatarSplitQueueCutoffs() const Lib::vvector Options::sineLevelSplitQueueRatios() const { - CALL("Options::sineLevelSplitQueueRatios"); auto inputRatios = parseCommaSeparatedList(_sineLevelSplitQueueRatios.actualValue); // sanity checks @@ -3731,7 +3673,6 @@ Lib::vvector Options::sineLevelSplitQueueRatios() const Lib::vvector Options::sineLevelSplitQueueCutoffs() const { - CALL("Options::sineLevelSplitQueueCutoffs"); // initialize cutoffs and add float-max as last value auto cutoffs = parseCommaSeparatedList(_sineLevelSplitQueueCutoffs.actualValue); cutoffs.push_back(std::numeric_limits::max()); @@ -3752,7 +3693,6 @@ Lib::vvector Options::sineLevelSplitQueueCutoffs() const Lib::vvector Options::positiveLiteralSplitQueueRatios() const { - CALL("Options::positiveLiteralSplitQueueRatios"); auto inputRatios = parseCommaSeparatedList(_positiveLiteralSplitQueueRatios.actualValue); // sanity checks @@ -3770,7 +3710,6 @@ Lib::vvector Options::positiveLiteralSplitQueueRatios() const Lib::vvector Options::positiveLiteralSplitQueueCutoffs() const { - CALL("Options::positiveLiteralSplitQueueCutoffs"); // initialize cutoffs and add float-max as last value auto cutoffs = parseCommaSeparatedList(_positiveLiteralSplitQueueCutoffs.actualValue); cutoffs.push_back(std::numeric_limits::max()); diff --git a/Shell/Options.hpp b/Shell/Options.hpp index cce9192d1..a27a663a4 100644 --- a/Shell/Options.hpp +++ b/Shell/Options.hpp @@ -898,7 +898,6 @@ class Options // For use in showOptions and explainOption //virtual void output(vstringstream& out) const { virtual void output(ostream& out,bool linewrap) const { - CALL("Options::AbstractOptionValue::output"); out << "--" << longName; if(!shortName.empty()){ out << " (-"< RandEntry; void setRandomChoices(std::initializer_list list){ - CALL("AbstractOptionValue::setRandomChoices(std::initializer_list list)"); rand_choices.push(RandEntry(OptionProblemConstraintUP(),toArray(list))); } void setRandomChoices(std::initializer_list list, std::initializer_list list_sat){ - CALL("AbstractOptionValue::setRandomChoices(std::initializer_list list, std::initializer_list list_sat)"); rand_choices.push(RandEntry(isRandOn(),toArray(list))); rand_choices.push(RandEntry(isRandSat(),toArray(list_sat))); } void setRandomChoices(OptionProblemConstraintUP c, std::initializer_list list){ - CALL("AbstractOptionValue::setRandomChoices(OptionProblemConstraintUP c, std::initializer_list list)"); rand_choices.push(RandEntry(std::move(c),toArray(list))); } void setNoPropertyRandomChoices(std::initializer_list list){ - CALL("AbstractOptionValue::setNoPropertyRandomChoices(std::initializer_list list)"); rand_choices.push(RandEntry(OptionProblemConstraintUP(),toArray(list))); supress_problemconstraints=true; } @@ -1070,7 +1065,6 @@ class Options virtual bool checkProblemConstraints(Property* prop); virtual void output(ostream& out, bool linewrap) const { - CALL("Options::OptionValue::output"); AbstractOptionValue::output(out,linewrap); out << "\tdefault: " << getStringOfValue(defaultValue) << endl; } @@ -1369,7 +1363,6 @@ OptionValue(l,s,def) {}; bool setValue(const vstring& value); virtual void output(ostream& out,bool linewrap) const { - CALL("Options::TimeLimitOptionValue::output"); AbstractOptionValue::output(out,linewrap); out << "\tdefault: " << defaultValue << "d" << endl; } @@ -1840,7 +1833,6 @@ bool _hard; CategoryCondition(Property::Category c,bool h) : cat(c), has(h) {} bool check(Property*p){ - CALL("Options::CategoryCondition::check"); ASS(p); return has ? p->category()==cat : p->category()!=cat; } @@ -1858,7 +1850,6 @@ bool _hard; USE_ALLOCATOR(UsesEquality); bool check(Property*p){ - CALL("Options::UsesEquality::check"); ASS(p) return (p->equalityAtoms() != 0) || // theories may introduce equality at various places of the pipeline! @@ -1872,7 +1863,6 @@ bool _hard; USE_ALLOCATOR(HasHigherOrder); bool check(Property*p){ - CALL("Options::HasHigherOrder::check"); ASS(p) return (p->higherOrder()); } @@ -1884,7 +1874,6 @@ bool _hard; USE_ALLOCATOR(OnlyFirstOrder); bool check(Property*p){ - CALL("Options::OnlyFirstOrder::check"); ASS(p) return (!p->higherOrder()); } @@ -1896,7 +1885,6 @@ bool _hard; USE_ALLOCATOR(MayHaveNonUnits); bool check(Property*p){ - CALL("Options::MayHaveNonUnits::check"); return (p->formulas() > 0) // let's not try to guess what kind of clauses these will give rise to || (p->clauses() > p->unitClauses()); } @@ -1908,7 +1896,6 @@ bool _hard; USE_ALLOCATOR(NotJustEquality); bool check(Property*p){ - CALL("Options::NotJustEquality::check"); return (p->category()!=Property::PEQ || p->category()!=Property::UEQ); } vstring msg(){ return " not useful with just equality"; } @@ -1922,7 +1909,6 @@ bool _hard; int atoms; bool greater; bool check(Property*p){ - CALL("Options::AtomConstraint::check"); return greater ? p->atoms()>atoms : p->atoms()hasFormulas(); } vstring msg(){ return " only useful with (non-cnf) formulas"; } @@ -1959,7 +1944,6 @@ bool _hard; USE_ALLOCATOR(HasGoal); bool check(Property*p){ - CALL("Options::HasGoal::check"); return p->hasGoal(); } vstring msg(){ return " only useful with a goal: (conjecture) formulas or (negated_conjecture) clauses"; } @@ -2011,7 +1995,6 @@ bool _hard; ManyOptionProblemConstraints(bool a) : is_and(a) {} bool check(Property*p){ - CALL("Options::ManyOptionProblemConstraints::check"); bool res = is_and; Stack::RefIterator it(cons); while(it.hasNext()){ @@ -2442,7 +2425,6 @@ bool _hard; public: void insert(AbstractOptionValue* option_value){ - CALL("LookupWrapper::insert"); ASS(!option_value->longName.empty()); bool new_long = _longMap.insert(option_value->longName,option_value); bool new_short = true; @@ -2453,12 +2435,10 @@ bool _hard; ASS(new_long && new_short); } AbstractOptionValue* findLong(vstring longName) const{ - CALL("LookupWrapper::findLong"); if(!_longMap.find(longName)){ throw ValueNotFoundException(); } return _longMap.get(longName); } AbstractOptionValue* findShort(vstring shortName) const{ - CALL("LookupWrapper::findShort"); if(!_shortMap.find(shortName)){ throw ValueNotFoundException(); } return _shortMap.get(shortName); } diff --git a/Shell/PredicateDefinition.cpp b/Shell/PredicateDefinition.cpp index b923c5b89..df27aa6f1 100644 --- a/Shell/PredicateDefinition.cpp +++ b/Shell/PredicateDefinition.cpp @@ -79,8 +79,6 @@ struct PredicateDefinition::PredData void add(int polarity, int add, PredicateDefinition* pdObj) { - CALL("PredicateDefinition::PredData::add"); - switch (polarity) { case -1: nocc += add; @@ -104,8 +102,6 @@ struct PredicateDefinition::PredData void check(PredicateDefinition* pdObj) { - CALL("PredicateDefinition::PredData::check"); - //we don't remove anything that concerns interpreted predicates if(builtIn) { return; @@ -179,7 +175,6 @@ PredicateDefinition::~PredicateDefinition() */ void PredicateDefinition::addBuiltInPredicate(unsigned pred) { - CALL("PredicateDefinition::addBuiltInPredicate"); ASS_L(pred,_predCnt); _preds[pred].builtIn = true; @@ -194,8 +189,6 @@ void PredicateDefinition::addBuiltInPredicate(unsigned pred) Unit* PredicateDefinition::getReplacement(Unit* u, ReplMap& replacements) { - CALL("PredicateDefinition::getReplacement(Unit*,ReplMap&)"); - Unit* tgt; while(replacements.find(u,tgt)) { u=tgt; @@ -205,8 +198,6 @@ Unit* PredicateDefinition::getReplacement(Unit* u, ReplMap& replacements) FormulaUnit* PredicateDefinition::getReplacement(FormulaUnit* u, ReplMap& replacements) { - CALL("PredicateDefinition::getReplacement(FormulaUnit*,ReplMap&)"); - Unit* res0 = getReplacement(static_cast(u), replacements); ASS(!res0 || !res0->isClause()); //we never transform FormulaUnit into Clause return static_cast(res0); @@ -215,8 +206,6 @@ FormulaUnit* PredicateDefinition::getReplacement(FormulaUnit* u, ReplMap& replac void PredicateDefinition::eliminatePredicateDefinition(unsigned pred, ReplMap& replacements) { - CALL("PredicateDefinition::eliminatePredicateDefinition"); - PredData& pd=_preds[pred]; ASS(pd.defUnit); FormulaUnit* def0 = pd.defUnit; @@ -279,8 +268,6 @@ void PredicateDefinition::eliminatePredicateDefinition(unsigned pred, ReplMap& r void PredicateDefinition::replacePurePred(unsigned pred, ReplMap& replacements) { - CALL("PredicateDefinition::replacePurePred"); - PredData& pd=_preds[pred]; ASS(pd.pocc==0 || pd.nocc==0); @@ -322,8 +309,6 @@ void PredicateDefinition::replacePurePred(unsigned pred, ReplMap& replacements) */ void PredicateDefinition::collectReplacements(UnitList* units, ReplMap& replacements) { - CALL("PredicateDefinition::collectReplacements"); - UnitList::Iterator scanIterator(units); while(scanIterator.hasNext()) { scan(scanIterator.next()); @@ -365,16 +350,12 @@ void PredicateDefinition::collectReplacements(UnitList* units, ReplMap& replacem void PredicateDefinition::removeUnusedDefinitionsAndPurePredicates(Problem& prb) { - CALL("PredicateDefinition::removeUnusedDefinitionsAndPurePredicates"); - ScopedLet prbLet(_processedPrb, &prb); removeUnusedDefinitionsAndPurePredicates(prb.units()); } void PredicateDefinition::removeUnusedDefinitionsAndPurePredicates(UnitList*& units) { - CALL("PredicateDefinition::removeUnusedDefinitionsAndPurePredicates"); - static DHMap replacements; replacements.reset(); @@ -436,8 +417,6 @@ Unit* PredicateDefinition::replacePurePredicates(Unit* u) Formula* PredicateDefinition::replacePurePredicates(Formula* f) { - CALL("PredicateDefinition::replacePurePredicates"); - Connective con = f->connective(); switch (con) { case LITERAL: @@ -743,8 +722,6 @@ void PredicateDefinition::scan(Clause* cl) void PredicateDefinition::scan(FormulaUnit* unit) { - CALL("PredicateDefinition::scan(FormulaUnit)"); - count(unit, 1); Formula* f=unit->formula(); @@ -776,7 +753,6 @@ void PredicateDefinition::scan(FormulaUnit* unit) void PredicateDefinition::count (Unit* u,int add) { - CALL("PredicateDefinition::count(Unit*,int)"); if(!u) { return; } @@ -790,7 +766,6 @@ void PredicateDefinition::count (Unit* u,int add) void PredicateDefinition::count (Clause* cl, int add) { - CALL("PredicateDefinition::count(Clause*,int)"); unsigned clen=cl->length(); for(unsigned i=0;iconnective()) { case LITERAL: { @@ -867,8 +840,6 @@ void PredicateDefinition::count (Formula* f,int polarity,int add, Unit* unit) void PredicateDefinition::count (TermList ts,int add, Unit* unit) { - CALL("PredicateDefinition::count(TermList,...)"); - if (ts.isVar()) { return; } @@ -915,8 +886,6 @@ void PredicateDefinition::count (TermList ts,int add, Unit* unit) bool PredicateDefinition::tryGetDef(Literal* lhs, Formula* rhs, FormulaUnit* unit) { - CALL("PredicateDefinition::tryGetDef"); - if(lhs->isEquality()) { return false; } diff --git a/Shell/Preprocess.cpp b/Shell/Preprocess.cpp index db0c8077f..f2ad74a36 100644 --- a/Shell/Preprocess.cpp +++ b/Shell/Preprocess.cpp @@ -14,7 +14,6 @@ * @since 02/06/2007 Manchester, changed to new datastructures */ -#include "Debug/Tracer.hpp" #include "Lib/ScopedLet.hpp" @@ -74,8 +73,6 @@ using namespace Shell; */ void Preprocess::preprocess(Problem& prb) { - CALL("Preprocess::preprocess"); - if(env.options->choiceReasoning()){ env.signature->addChoiceOperator(env.signature->getChoice()); } @@ -485,8 +482,6 @@ void Preprocess::preprocess(Problem& prb) */ void Preprocess::preprocess1 (Problem& prb) { - CALL("Preprocess::preprocess1"); - ScopedLet epLet(env.statistics->phase, Statistics::PREPROCESS_1); bool formulasSimplified = false; @@ -538,8 +533,6 @@ void Preprocess::preprocess1 (Problem& prb) */ void Preprocess::preprocess2(Problem& prb) { - CALL("Preprocess::preprocess2"); - env.statistics->phase=Statistics::PREPROCESS_2; UnitList::DelIterator us(prb.units()); @@ -567,7 +560,6 @@ void Preprocess::preprocess2(Problem& prb) */ void Preprocess::naming(Problem& prb) { - CALL("Preprocess::naming"); ASS(_options.naming()); env.statistics->phase=Statistics::NAMING; @@ -596,8 +588,6 @@ void Preprocess::naming(Problem& prb) */ void Preprocess::newCnf(Problem& prb) { - CALL("Preprocess::newCnf"); - env.statistics->phase=Statistics::NEW_CNF; // TODO: this is an ugly copy-paste of "Preprocess::clausify" @@ -662,8 +652,6 @@ void Preprocess::newCnf(Problem& prb) */ Unit* Preprocess::preprocess3 (Unit* u, bool appify /*higher order stuff*/) { - CALL("Preprocess::preprocess3(Unit*)"); - if (u->isClause()) { return u; } @@ -695,8 +683,6 @@ Unit* Preprocess::preprocess3 (Unit* u, bool appify /*higher order stuff*/) */ void Preprocess::preprocess3 (Problem& prb) { - CALL("Preprocess::preprocess3(Problem&)"); - bool modified = false; env.statistics->phase=Statistics::PREPROCESS_3; @@ -717,8 +703,6 @@ void Preprocess::preprocess3 (Problem& prb) void Preprocess::clausify(Problem& prb) { - CALL("Preprocess::clausify"); - env.statistics->phase=Statistics::CLAUSIFICATION; //we check if we haven't discovered an empty clause during preprocessing diff --git a/Shell/Profile.cpp b/Shell/Profile.cpp index a1dfed5c0..6d5e5326d 100644 --- a/Shell/Profile.cpp +++ b/Shell/Profile.cpp @@ -13,7 +13,6 @@ * @since 15/06/2008 Kemerovo */ -#include "Debug/Tracer.hpp" #include "Lib/Int.hpp" #include "Lib/Sort.hpp" #include "Lib/Environment.hpp" @@ -157,15 +156,11 @@ void Profile::output(const Clause* clause,ostream& str) Profile::VarCounter::VarCounter() : Array(15) { - CALL("Profile::VarCounter::VarCounter"); - fillInterval(0,15); } // Profile::VarCounter::VarCounter void Profile::VarCounter::fillInterval(size_t start,size_t end) { - CALL("Profile::VarCounter::fillInterval"); - for (size_t i = start;i < end;i++) { _array[i] = 0; } @@ -178,8 +173,6 @@ void Profile::VarCounter::fillInterval(size_t start,size_t end) Profile::Profile () : _numberOfClauses(0) { - CALL("Profile::Profile"); - for (int i = HOW_MANY-1;i >= 0;i--) { _vars[i] = 0; } @@ -204,8 +197,6 @@ Profile::Profile () Profile::~Profile() { - CALL("Profile::~Profile"); - DEALLOC_UNKNOWN(_funs,"Profile::funs"); DEALLOC_UNKNOWN(_funClauses,"Profile::funClauses"); DEALLOC_UNKNOWN(_posPreds,"Profile::posPreds"); @@ -220,8 +211,6 @@ Profile::~Profile() */ void Profile::scan(const UnitList* units) { - CALL("Profile::scan(UnitList*)"); - Signature* sig = env.signature; int fn = sig->functions(); for (int i = fn-1;i >= 0;i--) { @@ -290,8 +279,6 @@ void Profile::scan(const UnitList* units) */ void Profile::scan (const Clause* clause) { - CALL("Profile::scan (const Clause*)"); - _varsInThisClause = 0; _symsInThisClause = 0; _currentClause = clause; @@ -334,7 +321,6 @@ void Profile::scan (const Clause* clause) */ void Profile::scan (const Literal* lit) { - CALL("Profile::scan (const Literal*...)"); if (lit->isPositive()) { _posPreds[lit->functor()]++; } @@ -357,8 +343,6 @@ void Profile::scan (const Literal* lit) */ void Profile::scan(const TermList* ts) { - CALL("Profile::scan(TermList*))"); - Stack stack(64); for (;;) { @@ -464,8 +448,6 @@ vstring Profile::toString () const */ int Profile::evaluate(const Clause* c) { - CALL("Profile::evaluate"); - bool hasPos = false; int length = c->length(); int product = 1; diff --git a/Shell/Property.cpp b/Shell/Property.cpp index 219ade737..679ac1590 100644 --- a/Shell/Property.cpp +++ b/Shell/Property.cpp @@ -15,7 +15,6 @@ * @since 17/07/2003 Manchester, changed to new representation */ -#include "Debug/Tracer.hpp" #include "Lib/Int.hpp" #include "Lib/Environment.hpp" @@ -99,8 +98,6 @@ Property::Property() */ Property* Property::scan(UnitList* units) { - CALL("Property::scan"); - // a bit of a hack, these counts belong in Property for(unsigned f=0;ffunctions();f++){ env.signature->getFunction(f)->resetUsageCnt(); @@ -122,8 +119,6 @@ Property* Property::scan(UnitList* units) */ void Property::add(UnitList* units) { - CALL("Property::add(UnitList*)"); - UnitList::Iterator us(units); while (us.hasNext()) { scan(us.next()); @@ -215,8 +210,6 @@ void Property::add(UnitList* units) */ void Property::scan(Unit* unit) { - CALL("Property::scan(const Unit*)"); - _symbolsInFormula.reset(); if (unit->isClause()) { @@ -258,8 +251,6 @@ void Property::scan(Unit* unit) */ void Property::scan(Clause* clause) { - CALL("Property::scan(const Clause*)"); - int positiveLiterals = 0; int negativeLiterals = 0; int equationalLiterals = 0; @@ -367,9 +358,6 @@ void Property::scan(Clause* clause) */ void Property::scan(FormulaUnit* unit) { - CALL("Property::scan(const FormulaUnit*)"); - - if (unit->inputType() == UnitInputType::AXIOM) { _axiomFormulas ++; } @@ -408,8 +396,6 @@ void Property::scan(FormulaUnit* unit) */ void Property::scan(Formula* f, int polarity) { - CALL("void Property::scan(Formula* formula, int polarity)"); - _subformulas++; switch(f->connective()) { case LITERAL: { @@ -486,8 +472,6 @@ void Property::scan(Formula* f, int polarity) */ void Property::scanSort(TermList sort) { - CALL("Property::scanSort"); - if(sort.isVar()){ _hasNonDefaultSorts = true; return; @@ -575,8 +559,6 @@ void Property::scanSort(TermList sort) */ void Property::scan(Literal* lit, int polarity, unsigned cLen, bool goal) { - CALL("Property::scan(const Literal*...)"); - if (lit->isEquality()) { TermList eqSort = SortHelper::getEqualityArgumentSort(lit); TermList lhs = *lit->nthArgument(0); @@ -646,8 +628,6 @@ void Property::scan(Literal* lit, int polarity, unsigned cLen, bool goal) */ void Property::scan(TermList ts,bool unit,bool goal) { - CALL("Property::scan(TermList)"); - if (ts.isVar()) { _variablesInThisClause++; return; @@ -746,8 +726,6 @@ void Property::scan(TermList ts,bool unit,bool goal) void Property::scanForInterpreted(Term* t) { - CALL("Property::scanInterpretation"); - Interpretation itp; if (t->isLiteral()) { Literal* lit = static_cast(t); @@ -804,7 +782,6 @@ void Property::scanForInterpreted(Term* t) */ vstring Property::categoryString() const { - CALL("vstring Property::categoryString() const"); return categoryToString(_category); } vstring Property::categoryToString(Category cat) @@ -893,8 +870,6 @@ vstring Property::toString() const */ bool Property::hasXEqualsY(const Clause* c) { - CALL("Property::hasXEqualsY (const Clause*)"); - for (int i = c->length()-1; i >= 0; i--) { const Literal* lit = (*c)[i]; if (lit->isNegative()) { @@ -932,8 +907,6 @@ bool Property::hasXEqualsY(const Clause* c) */ bool Property::hasXEqualsY(const Formula* f) { - CALL("Property::hasXEqualsY (const Formula*)"); - MultiCounter posVars; // universally quantified variables in positive subformulas MultiCounter negVars; // universally quantified variables in negative subformulas diff --git a/Shell/Property.hpp b/Shell/Property.hpp index f7296e7d1..c9fe2bb28 100644 --- a/Shell/Property.hpp +++ b/Shell/Property.hpp @@ -236,7 +236,6 @@ class Property hasArrowSort() || _hasLambda; } bool quantifiesOverPolymorphicVar() const { return _quantifiesOverPolymorphicVar; } bool usesSort(unsigned sort) const { - CALL("Property::usesSort"); if(_usesSort.size() <= sort) return false; return _usesSort[sort]; } //TODO only utilised by FMB which should eventually update to use the new sorts (as TermLists) @@ -246,7 +245,6 @@ class Property bool knownInfiniteDomain() const { return _knownInfiniteDomain; } void setSMTLIBLogic(SMTLIBLogic smtLibLogic) { - CALL("Property::setSMTLIBLogic"); _smtlibLogic = smtLibLogic; } SMTLIBLogic getSMTLIBLogic() const { diff --git a/Shell/Rectify.cpp b/Shell/Rectify.cpp index 26917c5cd..5886181af 100644 --- a/Shell/Rectify.cpp +++ b/Shell/Rectify.cpp @@ -36,8 +36,6 @@ using namespace Shell; bool Rectify::Renaming::tryGetBoundAndMarkUsed (int var,int& boundTo) const { - CALL("Rectify::Renaming::tryGetBoundAndMarkUsed"); - if ((unsigned)var >= _capacity) { return false; } @@ -52,8 +50,6 @@ bool Rectify::Renaming::tryGetBoundAndMarkUsed (int var,int& boundTo) const Rectify::VarWithUsageInfo Rectify::Renaming::getBoundAndUsage(int var) const { - CALL("Rectify::Renaming::getBoundAndUsage"); - ASS_L((unsigned)var,_capacity); VarUsageTrackingList* vs = _array[var]; @@ -71,7 +67,6 @@ Rectify::VarWithUsageInfo Rectify::Renaming::getBoundAndUsage(int var) const */ FormulaUnit* Rectify::rectify (FormulaUnit* unit0, bool removeUnusedVars) { - CALL("Rectify::rectify (Unit*...)"); ASS(!unit0->isClause()); FormulaUnit* unit = unit0; @@ -99,8 +94,6 @@ FormulaUnit* Rectify::rectify (FormulaUnit* unit0, bool removeUnusedVars) */ void Rectify::rectify(UnitList*& units) { - CALL("Rectify::rectify(UnitList*&)"); - UnitList::DelIterator us(units); while (us.hasNext()) { Unit* u = us.next(); @@ -121,8 +114,6 @@ void Rectify::rectify(UnitList*& units) */ Rectify::Renaming::~Renaming () { - CALL("Rectify::Renaming::~Renaming"); - for (int i = _capacity-1;i >= 0;i--) { VarUsageTrackingList::destroy(_array[i]); _array[i] = 0; @@ -136,8 +127,6 @@ Rectify::Renaming::~Renaming () */ Term* Rectify::rectifySpecialTerm(Term* t) { - CALL("Rectify::rectifySpecialTerm"); - Term::SpecialTermData* sd = t->getSpecialData(); switch(t->specialFunctor()) { case Term::SpecialFunctor::ITE: @@ -270,8 +259,6 @@ Term* Rectify::rectifySpecialTerm(Term* t) */ Term* Rectify::rectify (Term* t) { - CALL("Rectify::rectify(Term*)"); - if (t->shared() && t->ground()) { return t; } @@ -300,8 +287,6 @@ Term* Rectify::rectify (Term* t) SList* Rectify::rectifySortList(SList* from, bool& modified) { - CALL("rectifySortList"); - modified = false; SList* to = SList::empty(); SList::Iterator slit(from); @@ -318,7 +303,6 @@ SList* Rectify::rectifySortList(SList* from, bool& modified) Literal* Rectify::rectifyShared(Literal* lit) { - CALL("Rectify::rectifyShared"); ASS(lit->shared()); return SubstHelper::apply(lit, *this); @@ -330,8 +314,6 @@ Literal* Rectify::rectifyShared(Literal* lit) */ Literal* Rectify::rectify (Literal* l) { - CALL("Rectify::rectify(Literal*)"); - if (l->shared()) { if(l->ground()) { return l; @@ -380,8 +362,6 @@ Literal* Rectify::rectify (Literal* l) */ bool Rectify::rectify(TermList* from,TermList* to) { - CALL("Rectify::rectify(TermList* ...)"); - bool changed = false; while (! from->isEmpty()) { if (from->isVar()) { @@ -413,8 +393,6 @@ bool Rectify::rectify(TermList* from,TermList* to) */ unsigned Rectify::rectifyVar(unsigned v) { - CALL("Rectify::rectifyVar"); - int newV; if (! _renaming.tryGetBoundAndMarkUsed(v,newV)) { newV = _renaming.bind(v); @@ -429,8 +407,6 @@ unsigned Rectify::rectifyVar(unsigned v) */ TermList Rectify::rectify(TermList t) { - CALL("Rectify::rectify"); - if(t.isTerm()) { return TermList(rectify(t.term())); } @@ -452,8 +428,6 @@ TermList Rectify::rectify(TermList t) */ Formula* Rectify::rectify (Formula* f) { - CALL("Rectify::rectify (Formula*)"); - switch (f->connective()) { case LITERAL: { @@ -532,8 +506,6 @@ Formula* Rectify::rectify (Formula* f) */ void Rectify::Renaming::undoBinding (unsigned var) { - CALL("Rectify::Renaming::undoBinding"); - ASS(var < _capacity); VarUsageTrackingList::pop(_array[var]); @@ -545,8 +517,6 @@ void Rectify::Renaming::undoBinding (unsigned var) */ unsigned Rectify::Renaming::bind (unsigned var) { - CALL("Rectify::Renaming::bind"); - unsigned result; if(VarManager::varNamePreserving()) { @@ -571,8 +541,6 @@ unsigned Rectify::Renaming::bind (unsigned var) */ void Rectify::bindVars(VList* vs) { - CALL ("Rectify::bindVars (VarList*)"); - VList::Iterator vit(vs); while(vit.hasNext()) { unsigned v = vit.next(); @@ -585,8 +553,6 @@ void Rectify::bindVars(VList* vs) */ void Rectify::unbindVars(VList* vs) { - CALL ("Rectify::unbindVars (VarList*)"); - VList::Iterator vit(vs); while(vit.hasNext()) { unsigned v = vit.next(); @@ -601,8 +567,6 @@ void Rectify::unbindVars(VList* vs) */ VList* Rectify::rectifyBoundVars (VList* vs) { - CALL ("Rectify::rectifyBoundVars(VarList*)"); - if (VList::isEmpty(vs)) { return vs; } @@ -653,8 +617,6 @@ VList* Rectify::rectifyBoundVars (VList* vs) */ FormulaList* Rectify::rectify (FormulaList* fs) { - CALL ("Rectify::rectify (FormulaList*)"); - Recycled> els; FormulaList* el = fs; diff --git a/Shell/Shuffling.cpp b/Shell/Shuffling.cpp index 29c672fd1..fc2539bb9 100644 --- a/Shell/Shuffling.cpp +++ b/Shell/Shuffling.cpp @@ -36,8 +36,6 @@ using namespace Shell; */ void Shuffling::polarityFlip(Problem& prb) { - CALL("Shuffling::polarityFlip (Problem&)"); - DArray flippage(env.signature->predicates()); for (unsigned p = 0; p < flippage.size(); p++) { @@ -86,8 +84,6 @@ void Shuffling::polarityFlip(Problem& prb) */ void Shuffling::shuffle(Problem& prb) { - CALL("Shuffling::shuffle (Problem&)"); - shuffle(prb.units()); } @@ -98,8 +94,6 @@ void Shuffling::shuffle(Problem& prb) */ void Shuffling::shuffle (UnitList*& units) { - CALL("Shuffling::shuffle (UnitList*&)"); - UnitList::Iterator us(units); while (us.hasNext()) { shuffle(us.next()); @@ -110,8 +104,6 @@ void Shuffling::shuffle (UnitList*& units) void Shuffling::shuffle(Unit* unit) { - CALL("Shuffling::shuffle (Unit*"); - // cout << "Bef: " << unit->toString() << endl; if (unit->isClause()) { @@ -125,8 +117,6 @@ void Shuffling::shuffle(Unit* unit) void Shuffling::shuffle(Clause* clause) { - CALL("Shuffling::shuffle (Clause*)"); - unsigned s = clause->numSelected(); // don't shuffle between selected and non-selected literals @@ -140,8 +130,6 @@ void Shuffling::shuffle(Clause* clause) // iterative implementation of shuffling Formula* / Literal* / TermList void Shuffling::shuffleIter(Shufflable sh) { - CALL("Shuffling::shuffleIter"); - static Stack todo; ASS(todo.isEmpty()); diff --git a/Shell/Shuffling.hpp b/Shell/Shuffling.hpp index c102b72d8..3fff2c698 100644 --- a/Shell/Shuffling.hpp +++ b/Shell/Shuffling.hpp @@ -58,8 +58,6 @@ class Shuffling template // Implements Fisher–Yates shuffling (each permutation equally likely) static void shuffleArray(Arrayish& a, unsigned len) { - CALL("Shuffling::shuffleArray"); - for(unsigned i=0;i static void shuffleList(List*& list) { - CALL("Shuffling::shuffleList"); - unsigned len = List::length(list); if (len <= 1) { @@ -106,8 +102,6 @@ class Shuffling // they get shuffled "in sync" template static void shuffleTwoList(List*& list1, List*& list2) { - CALL("Shuffling::shuffleTwoList"); - unsigned len = List::length(list1); if (len <= 1) { diff --git a/Shell/SimplifyFalseTrue.cpp b/Shell/SimplifyFalseTrue.cpp index efa65be5c..db955b2b8 100644 --- a/Shell/SimplifyFalseTrue.cpp +++ b/Shell/SimplifyFalseTrue.cpp @@ -40,7 +40,6 @@ using namespace Lib; */ FormulaUnit* SimplifyFalseTrue::simplify (FormulaUnit* unit) { - CALL("SimplifyFalseTrue::simplify(Unit*)"); ASS(! unit->isClause()); Formula* f = unit->formula(); @@ -72,8 +71,6 @@ FormulaUnit* SimplifyFalseTrue::simplify (FormulaUnit* unit) */ Formula* SimplifyFalseTrue::innerSimplify (Formula* f) { - CALL("SimplifyFalseTrue::innerSimplify(Formula*)"); - Connective con = f->connective(); switch (con) { case TRUE: @@ -325,8 +322,6 @@ Formula* SimplifyFalseTrue::innerSimplify (Formula* f) TermList SimplifyFalseTrue::simplify(TermList ts) { - CALL("SimplifyFalseTrue::simplify(TermList)"); - if (ts.isVar()) { return ts; } diff --git a/Shell/SineUtils.cpp b/Shell/SineUtils.cpp index faab02bcf..8369f5df3 100644 --- a/Shell/SineUtils.cpp +++ b/Shell/SineUtils.cpp @@ -61,8 +61,6 @@ SineSymbolExtractor::SymId SineSymbolExtractor::getSymIdBound() void SineSymbolExtractor::addSymIds(Term* term, DHSet& ids) { - CALL("SineSymbolExtractor::addSymIds"); - if (!term->shared()) { if (term->isSpecial()) { Term::SpecialTermData *sd = term->getSpecialData(); @@ -127,8 +125,6 @@ void SineSymbolExtractor::addSymIds(Term* term, DHSet& ids) */ void SineSymbolExtractor::addSymIds(Literal* lit,DHSet& ids) { - CALL("SineSymbolExtractor::addSymIds"); - SymId predId=lit->functor()*3; ids.insert(predId); @@ -158,8 +154,6 @@ void SineSymbolExtractor::decodeSymId(SymId s, bool& pred, unsigned& functor) bool SineSymbolExtractor::validSymId(SymId s) { - CALL("SineSymbolExtractor::validSymId"); - bool pred; unsigned functor; decodeSymId(s, pred, functor); @@ -183,7 +177,6 @@ bool SineSymbolExtractor::validSymId(SymId s) */ void SineSymbolExtractor::extractFormulaSymbols(Formula* f,DHSet& itms) { - CALL("SineSymbolExtractor::extractFormulaSymbols"); Stack fs; fs.push(f); while (!fs.isEmpty()) { @@ -237,8 +230,6 @@ void SineSymbolExtractor::extractFormulaSymbols(Formula* f,DHSet& itms) */ SineSymbolExtractor::SymIdIterator SineSymbolExtractor::extractSymIds(Unit* u) { - CALL("SineSymbolExtractor::extractSymIds"); - static DHSet itms; itms.reset(); @@ -262,8 +253,6 @@ SineSymbolExtractor::SymIdIterator SineSymbolExtractor::extractSymIds(Unit* u) void SineBase::initGeneralityFunction(UnitList* units) { - CALL("SineBase::initGeneralityFunction"); - SymId symIdBound=_symExtr.getSymIdBound(); _gen.init(symIdBound,0); @@ -285,8 +274,6 @@ SineSelector::SineSelector(const Options& opt) _depthLimit(opt.sineDepth()), _justForSineLevels(false) { - CALL("SineSelector::SineSelector/0"); - init(); } @@ -297,14 +284,11 @@ SineSelector::SineSelector(bool onIncluded, float tolerance, unsigned depthLimit _depthLimit(depthLimit), _justForSineLevels(justForSineLevels) { - CALL("SineSelector::SineSelector/4"); - init(); } void SineSelector::init() { - CALL("SineSelector::init"); ASS(_tolerance>=1.0f || _tolerance==-1); _strict=_tolerance==1.0f; @@ -315,8 +299,6 @@ void SineSelector::init() */ void SineSelector::updateDefRelation(Unit* u) { - CALL("SineSelector::updateDefRelation"); - SymIdIterator sit=_symExtr.extractSymIds(u); if (!sit.hasNext()) { @@ -392,8 +374,6 @@ void SineSelector::updateDefRelation(Unit* u) void SineSelector::perform(Problem& prb) { - CALL("SineSelector::perform"); - if (perform(prb.units())) { prb.reportIncompleteTransformation(); } @@ -402,8 +382,6 @@ void SineSelector::perform(Problem& prb) bool SineSelector::perform(UnitList*& units) { - CALL("SineSelector::perform"); - TIME_TRACE(TimeTrace::SINE_SELECTION); initGeneralityFunction(units); @@ -539,13 +517,10 @@ bool SineSelector::perform(UnitList*& units) SineTheorySelector::SineTheorySelector(const Options& opt) : _genThreshold(opt.sineGeneralityThreshold()), _opt(opt) { - CALL("SineTheorySelector::SineTheorySelector"); } void SineTheorySelector::handlePossibleSignatureChange() { - CALL("SineTheorySelector::handlePossibleSignatureChange"); - size_t symIdBound=_symExtr.getSymIdBound(); size_t oldSize=_def.size(); ASS_EQ(_gen.size(), oldSize); @@ -568,8 +543,6 @@ void SineTheorySelector::handlePossibleSignatureChange() */ void SineTheorySelector::updateDefRelation(Unit* u) { - CALL("SineTheorySelector::updateDefRelation"); - SymIdIterator sit0=_symExtr.extractSymIds(u); if (!sit0.hasNext()) { @@ -628,8 +601,6 @@ void SineTheorySelector::updateDefRelation(Unit* u) */ void SineTheorySelector::initSelectionStructure(UnitList* units) { - CALL("SineTheorySelector::initSelectionStructure"); - TIME_TRACE(TimeTrace::SINE_SELECTION); initGeneralityFunction(units); @@ -648,8 +619,6 @@ void SineTheorySelector::initSelectionStructure(UnitList* units) void SineTheorySelector::perform(UnitList*& units) { - CALL("SineTheorySelector::perform"); - TIME_TRACE(TimeTrace::SINE_SELECTION); handlePossibleSignatureChange(); diff --git a/Shell/Skolem.cpp b/Shell/Skolem.cpp index 5a8f9c25a..06063570d 100644 --- a/Shell/Skolem.cpp +++ b/Shell/Skolem.cpp @@ -48,7 +48,6 @@ using namespace Shell; */ FormulaUnit* Skolem::skolemise (FormulaUnit* unit, bool appify) { - CALL("Skolem::skolemise(Unit*)"); ASS(! unit->isClause()); unit = Rectify::rectify(unit); @@ -69,8 +68,6 @@ FormulaUnit* Skolem::skolemise (FormulaUnit* unit, bool appify) FormulaUnit* Skolem::skolemiseImpl (FormulaUnit* unit, bool appify) { - CALL("Skolem::skolemiseImpl(FormulaUnit*)"); - ASS(_introducedSkolemSyms.isEmpty()); _appify = appify; @@ -123,8 +120,6 @@ FormulaUnit* Skolem::skolemiseImpl (FormulaUnit* unit, bool appify) unsigned Skolem::addSkolemFunction(unsigned arity, TermList* domainSorts, TermList rangeSort, unsigned var, unsigned taArity) { - CALL("Skolem::addSkolemFunction(unsigned,unsigned*,unsigned,unsigned)"); - if(VarManager::varNamePreserving()) { vstring varName=VarManager::getVarName(var); return addSkolemFunction(arity, taArity, domainSorts, rangeSort, varName.c_str()); @@ -137,7 +132,6 @@ unsigned Skolem::addSkolemFunction(unsigned arity, TermList* domainSorts, unsigned Skolem::addSkolemFunction(unsigned arity, unsigned taArity, TermList* domainSorts, TermList rangeSort, const char* suffix) { - CALL("Skolem::addSkolemFunction(unsigned,TermList*,TermList,const char*)"); //ASS(arity==0 || domainSorts!=0); unsigned fun = env.signature->addSkolemFunction(arity, suffix); @@ -149,8 +143,6 @@ unsigned Skolem::addSkolemFunction(unsigned arity, unsigned taArity, TermList* d unsigned Skolem::addSkolemTypeCon(unsigned arity, unsigned var) { - CALL("Skolem::addSkolemTypeCon"); - if(VarManager::varNamePreserving()) { vstring varName=VarManager::getVarName(var); return addSkolemTypeCon(arity, varName.c_str()); @@ -162,8 +154,6 @@ unsigned Skolem::addSkolemTypeCon(unsigned arity, unsigned var) unsigned Skolem::addSkolemTypeCon(unsigned arity, const char* suffix) { - CALL("Skolem::addSkolemTypeCon"); - unsigned typeCon = env.signature->addSkolemTypeCon(arity, suffix); Signature::Symbol* tcSym = env.signature->getTypeCon(typeCon); OperatorType* ot = OperatorType::getTypeConType(arity); @@ -173,8 +163,6 @@ unsigned Skolem::addSkolemTypeCon(unsigned arity, const char* suffix) unsigned Skolem::addSkolemPredicate(unsigned arity, TermList* domainSorts, unsigned var, unsigned taArity) { - CALL("Skolem::addSkolemPredicate(unsigned,unsigned*,unsigned,unsigned)"); - if(VarManager::varNamePreserving()) { vstring varName=VarManager::getVarName(var); return addSkolemPredicate(arity, taArity, domainSorts, varName.c_str()); @@ -186,7 +174,6 @@ unsigned Skolem::addSkolemPredicate(unsigned arity, TermList* domainSorts, unsig unsigned Skolem::addSkolemPredicate(unsigned arity, unsigned taArity, TermList* domainSorts, const char* suffix) { - CALL("Skolem::addSkolemPredicate(unsigned,unsigned*,unsigned,const char*)"); //ASS(arity==0 || domainSorts!=0); unsigned pred = env.signature->addSkolemPredicate(arity, suffix); @@ -198,8 +185,6 @@ unsigned Skolem::addSkolemPredicate(unsigned arity, unsigned taArity, TermList* void Skolem::ensureHavingVarSorts() { - CALL("Skolem::ensureHavingVarSorts"); - if (_varSorts.size() == 0) { Formula* f = _beingSkolemised->formula(); SortHelper::collectVariableSorts(f, _varSorts); @@ -214,8 +199,6 @@ void Skolem::ensureHavingVarSorts() */ void Skolem::preskolemise (Formula* f) { - CALL("Skolem::preskolemise (Formula*)"); - switch (f->connective()) { case LITERAL: { @@ -359,8 +342,6 @@ void Skolem::preskolemise (Formula* f) */ Formula* Skolem::skolemise (Formula* f) { - CALL("Skolem::skolemise (Formula*)"); - switch (f->connective()) { case LITERAL: { @@ -574,8 +555,6 @@ Formula* Skolem::skolemise (Formula* f) */ FormulaList* Skolem::skolemise (FormulaList* fs) { - CALL("Skolem:skolemise(FormulaList*)"); - ASS(FormulaList::isNonEmpty(fs)); Stack args; diff --git a/Shell/SubexpressionIterator.cpp b/Shell/SubexpressionIterator.cpp index dd0b183c9..fa0d41a93 100644 --- a/Shell/SubexpressionIterator.cpp +++ b/Shell/SubexpressionIterator.cpp @@ -34,13 +34,10 @@ namespace Shell { } bool SubexpressionIterator::hasNext() { - CALL("SubexpressionIterator::hasNext"); return _subexpressions.isNonEmpty(); } SubexpressionIterator::Expression SubexpressionIterator::next() { - CALL("SubexpressionIterator::next"); - ASS(hasNext()); Expression expression = _subexpressions.pop(); int polarity = expression._polarity; diff --git a/Shell/SubexpressionIterator.hpp b/Shell/SubexpressionIterator.hpp index 2e5de03cb..27984148f 100644 --- a/Shell/SubexpressionIterator.hpp +++ b/Shell/SubexpressionIterator.hpp @@ -108,7 +108,6 @@ namespace Shell { FoolAwareSubformulaIterator(TermList ts): _sei(ts) {} bool hasNext() { - CALL("FoolAwareSubformulaIterator::hasNext"); while (_sei.hasNext()) { SubexpressionIterator::Expression expression = _sei.next(); if (expression.isFormula()) { @@ -124,7 +123,6 @@ namespace Shell { return next(dummy); } Formula* next(int& polarity) { - CALL("FoolAwareSubformulaIterator::next(int&)"); ASS(_next); polarity = _polarity; return _next; @@ -144,7 +142,6 @@ namespace Shell { FoolAwareSubtermIterator(TermList ts): _sei(ts) {} bool hasNext() { - CALL("FoolAwareSubtermIterator::hasNext"); while (_sei.hasNext()) { SubexpressionIterator::Expression expression = _sei.next(); if (expression.isTerm()) { diff --git a/Shell/SymCounter.cpp b/Shell/SymCounter.cpp index d83b9066a..cbef6455a 100644 --- a/Shell/SymCounter.cpp +++ b/Shell/SymCounter.cpp @@ -40,8 +40,6 @@ SymCounter::SymCounter (Signature& sig) _noOfFuns (sig.functions()), _noOfTypeCons(sig.typeCons()) { - CALL("SymCounter::SymCounter"); - if (_noOfPreds) { void* mem = ALLOC_KNOWN(_noOfPreds*sizeof(Pred),"SymCounter::Pred[]"); _preds = array_new(mem, _noOfPreds); @@ -65,8 +63,6 @@ SymCounter::SymCounter (Signature& sig) */ SymCounter::~SymCounter () { - CALL("SymCounter::~SymCounter"); - if (_noOfPreds) { array_delete(_preds,_noOfPreds); DEALLOC_KNOWN(_preds,_noOfPreds*sizeof(Pred),"SymCounter::Pred[]"); @@ -89,8 +85,6 @@ SymCounter::~SymCounter () */ void SymCounter::count (UnitList* units,int c) { - CALL("SymCounter::count (const UnitList*)"); - UnitList::Iterator us(units); while (us.hasNext()) { Unit* unit = us.next(); @@ -110,8 +104,6 @@ void SymCounter::count (UnitList* units,int c) */ void SymCounter::count (Clause* clause,int add) { - CALL("SymCounter::count(const Clause*)"); - for (int n = clause->length()-1;n >= 0;n--) { count((*clause)[n],true,add); } @@ -128,8 +120,6 @@ void SymCounter::count(Formula* f, int add) */ void SymCounter::count (Formula* f,int polarity,int add) { - CALL("SymCounter::count(const Formula*)"); - switch (f->connective()) { case LITERAL: count (f->literal(), polarity, add); @@ -188,8 +178,6 @@ void SymCounter::count (Formula* f,int polarity,int add) */ void SymCounter::count(Literal* l,int polarity,int add) { - CALL("SymCounter::count(const Literal*)"); - int pred = l->functor(); ASS(_noOfPreds > pred); @@ -229,8 +217,6 @@ void SymCounter::count(Literal* l,int polarity,int add) */ void SymCounter::count(Term* term, int polarity, int add) { - CALL("SymCounter::count(Term*)"); - if (!term->shared()) { if (term->isSpecial()) { Term::SpecialTermData *sd = term->getSpecialData(); @@ -315,8 +301,6 @@ void SymCounter::count(Term* term, int polarity, int add) */ void SymCounter::Pred::add(int polarity, int add) { - CALL("SymCounter::add"); - switch (polarity) { case -1: _nocc += add; diff --git a/Shell/SymbolDefinitionInlining.cpp b/Shell/SymbolDefinitionInlining.cpp index 2edde557a..f103970b6 100644 --- a/Shell/SymbolDefinitionInlining.cpp +++ b/Shell/SymbolDefinitionInlining.cpp @@ -18,8 +18,6 @@ using namespace Kernel; using namespace Shell; TermList SymbolDefinitionInlining::substitute(Term::Iterator tit) { - CALL("SymbolDefinitionInlining::substitute"); - Substitution substitution; VList::Iterator vit(_bindingVariables); @@ -63,8 +61,6 @@ TermList SymbolDefinitionInlining::substitute(Term::Iterator tit) { } TermList SymbolDefinitionInlining::process(TermList ts) { - CALL("SymbolDefinitionInlining::process(TermList)"); - if (ts.isVar()) { return ts; } @@ -227,8 +223,6 @@ bool SymbolDefinitionInlining::mirroredTuple(Term* tuple, TermList &tupleConstan } Formula* SymbolDefinitionInlining::process(Formula* formula) { - CALL("SymbolDefinitionInlining::process(Formula*)"); - switch (formula->connective()) { case LITERAL: { Literal* literal = formula->literal(); @@ -330,8 +324,6 @@ Formula* SymbolDefinitionInlining::process(Formula* formula) { } FormulaList* SymbolDefinitionInlining::process(FormulaList* formulas) { - CALL("SymbolDefinitionInlining::process(FormulaList*)"); - Stack elements(FormulaList::length(formulas)); bool substituted = false; @@ -359,8 +351,6 @@ FormulaList* SymbolDefinitionInlining::process(FormulaList* formulas) { } void SymbolDefinitionInlining::collectBoundVariables(TermList ts) { - CALL("SymbolDefinitionInlining::collectBoundVariables(TermList)"); - if (ts.isVar()) { return; } @@ -369,8 +359,6 @@ void SymbolDefinitionInlining::collectBoundVariables(TermList ts) { } void SymbolDefinitionInlining::collectBoundVariables(Term* t) { - CALL("SymbolDefinitionInlining::collectBoundVariables(Term*)"); - if (t->shared()) { return; } @@ -416,8 +404,6 @@ void SymbolDefinitionInlining::collectBoundVariables(Term* t) { } void SymbolDefinitionInlining::collectBoundVariables(Formula* formula) { - CALL("SymbolDefinitionInlining::collectBoundVariables(Formula*)"); - switch (formula->connective()) { case FORALL: case EXISTS: { diff --git a/Shell/SymbolOccurrenceReplacement.cpp b/Shell/SymbolOccurrenceReplacement.cpp index bc2651f6f..a5c5d5a05 100644 --- a/Shell/SymbolOccurrenceReplacement.cpp +++ b/Shell/SymbolOccurrenceReplacement.cpp @@ -18,7 +18,6 @@ using namespace Kernel; using namespace Shell; Term* SymbolOccurrenceReplacement::process(Term* term) { - CALL("FOOLElimination::SymbolOccurrenceReplacement::process(Term*)"); ASS(!term->isSort()); if (term->isSpecial()) { @@ -96,8 +95,6 @@ Term* SymbolOccurrenceReplacement::process(Term* term) { } TermList SymbolOccurrenceReplacement::process(TermList ts) { - CALL("SymbolOccurrenceReplacement::process(TermList)"); - if (!ts.isTerm()) { return ts; } @@ -106,7 +103,6 @@ TermList SymbolOccurrenceReplacement::process(TermList ts) { } Formula* SymbolOccurrenceReplacement::process(Formula* formula) { - CALL("SymbolOccurrenceReplacement::process(Formula*)"); switch (formula->connective()) { case LITERAL: { Literal* literal = formula->literal(); @@ -180,6 +176,5 @@ Formula* SymbolOccurrenceReplacement::process(Formula* formula) { } FormulaList* SymbolOccurrenceReplacement::process(FormulaList* formulas) { - CALL("SymbolOccurrenceReplacement::process(FormulaList*)"); return FormulaList::isEmpty(formulas) ? formulas : new FormulaList(process(formulas->head()), process(formulas->tail())); } diff --git a/Shell/TPTPPrinter.cpp b/Shell/TPTPPrinter.cpp index c9db0bec7..7b63b834f 100644 --- a/Shell/TPTPPrinter.cpp +++ b/Shell/TPTPPrinter.cpp @@ -42,7 +42,6 @@ namespace Shell TPTPPrinter::TPTPPrinter(ostream* tgtStream) : _tgtStream(tgtStream), _headersPrinted(false) { - CALL("TPTPPrinter::TPTPPrinter"); } /** @@ -50,8 +49,6 @@ TPTPPrinter::TPTPPrinter(ostream* tgtStream) */ void TPTPPrinter::print(Unit* u) { - CALL("TPTPPrinter::print"); - vstring body = getBodyStr(u, true); beginOutput(); @@ -67,14 +64,11 @@ void TPTPPrinter::print(Unit* u) */ void TPTPPrinter::printAsClaim(vstring name, Unit* u) { - CALL("TPTPPrinter::printAsClaim"); printWithRole(name, "claim", u); } void TPTPPrinter::printWithRole(vstring name, vstring role, Unit* u, bool includeSplitLevels) { - CALL("TPTPPrinter::printWithRole"); - vstring body = getBodyStr(u, includeSplitLevels); beginOutput(); @@ -91,8 +85,6 @@ void TPTPPrinter::printWithRole(vstring name, vstring role, Unit* u, bool includ */ vstring TPTPPrinter::getBodyStr(Unit* u, bool includeSplitLevels) { - CALL("TPTPPrinter::getBodyStr"); - vostringstream res; typedef DHMap SortMap; @@ -159,8 +151,6 @@ vstring TPTPPrinter::getBodyStr(Unit* u, bool includeSplitLevels) */ void TPTPPrinter::printTffWrapper(Unit* u, vstring bodyStr) { - CALL("TPTPPrinter::printTffWrapper"); - tgt() << "tff("; vstring unitName; if(Parse::TPTP::findAxiomName(u, unitName)) { @@ -196,8 +186,6 @@ void TPTPPrinter::printTffWrapper(Unit* u, vstring bodyStr) */ void TPTPPrinter::outputSymbolTypeDefinitions(unsigned symNumber, SymbolType symType) { - CALL("TPTPPrinter::outputSymbolTypeDefinitions"); - Signature::Symbol* sym; OperatorType* type; if(symType == SymbolType::FUNC){ @@ -261,7 +249,6 @@ void TPTPPrinter::outputSymbolTypeDefinitions(unsigned symNumber, SymbolType sym */ /*void TPTPPrinter::ensureNecesarySorts() { - CALL("TPTPPrinter::ensureNecesarySorts"); if (_headersPrinted) { return; } @@ -308,8 +295,6 @@ void TPTPPrinter::outputSymbolTypeDefinitions(unsigned symNumber, SymbolType sym */ void TPTPPrinter::ensureHeadersPrinted(Unit* u) { - CALL("TPTPPrinter::ensureHeadersPrinted"); - if(_headersPrinted) { return; } @@ -337,8 +322,6 @@ void TPTPPrinter::ensureHeadersPrinted(Unit* u) */ ostream& TPTPPrinter::tgt() { - CALL("TPTPPrinter::tgt"); - if(_tgtStream) { return *_tgtStream; } @@ -353,15 +336,11 @@ ostream& TPTPPrinter::tgt() */ void TPTPPrinter::beginOutput() { - CALL("TPTPPrinter::beginOutput"); - if(!_tgtStream) { env.beginOutput(); } } void TPTPPrinter::endOutput() { - CALL("TPTPPrinter::endOutput"); - if(!_tgtStream) { env.endOutput(); } } @@ -370,7 +349,6 @@ void TPTPPrinter::endOutput() */ vstring TPTPPrinter::toString(const Formula* formula) { - CALL("TPTPPrinter::toString(const Formula*)"); static vstring names [] = { "", " & ", " | ", " => ", " <=> ", " <~> ", "~", "!", "?", "$term", "$false", "$true", "", ""}; @@ -518,7 +496,6 @@ vstring TPTPPrinter::toString(const Formula* formula) */ vstring TPTPPrinter::toString (const Unit* unit) { - CALL("TPTPPrinter::toString(const Unit*)"); // const Inference* inf = unit->inference(); // Inference::Rule rule = inf->rule(); diff --git a/Shell/TermAlgebra.cpp b/Shell/TermAlgebra.cpp index 5c000d408..2779538b2 100644 --- a/Shell/TermAlgebra.cpp +++ b/Shell/TermAlgebra.cpp @@ -58,7 +58,6 @@ unsigned TermAlgebraConstructor::numTypeArguments() const { return _type->numTyp unsigned TermAlgebraConstructor::discriminator() { - CALL("TermAlgebraConstructor::discriminator"); if (hasDiscriminator()) { return _discriminator; } else { @@ -72,7 +71,6 @@ unsigned TermAlgebraConstructor::discriminator() Lib::Set TermAlgebra::subSorts(TermList sort) { - CALL("TermAlgebra::subSorts"); ASS(sort.isTerm() && sort.term()->isSort()); Set out; @@ -105,8 +103,6 @@ TermList TermAlgebraConstructor::rangeSort() const { return _type->res bool TermAlgebraConstructor::recursive() { - CALL("TermAlgebraConstructor::recursive"); - for (unsigned i=0; i < _type->arity(); i++) { if (_type->arg(i) == _type->result()) { // this constructor has a recursive argument @@ -118,8 +114,6 @@ bool TermAlgebraConstructor::recursive() Lib::vstring TermAlgebraConstructor::discriminatorName() { - CALL("TermAlgebraConstructor::discriminatorName"); - //Giles: the function name may contain quotes so we should remove them // before appending $is. vstring name = env.signature->functionName(_functor); @@ -169,8 +163,6 @@ TermAlgebra::TermAlgebra(TermList sort, bool TermAlgebra::emptyDomain() { - CALL("TermAlgebra::emptyDomain"); - if (_n == 0) { return true; } @@ -189,8 +181,6 @@ bool TermAlgebra::emptyDomain() bool TermAlgebra::finiteDomain() { - CALL("TermAlgebra::finiteDomain"); - for (unsigned i = 0; i < _n; i++) { if (_constrs[i]->arity() > 0) { return false; @@ -202,8 +192,6 @@ bool TermAlgebra::finiteDomain() bool TermAlgebra::infiniteDomain() { - CALL("TermAlgebra::infiniteDomain"); - for (unsigned i = 0; i < _n; i++) { if (_constrs[i]->recursive()) { return true; @@ -218,8 +206,6 @@ Lib::vstring TermAlgebra::getSubtermPredicateName() { } unsigned TermAlgebra::getSubtermPredicate() { - CALL("TermAlgebra::getSubtermPredicate"); - bool added; unsigned s = env.signature->addPredicate(getSubtermPredicateName(), nTypeArgs()+2, added); @@ -236,7 +222,6 @@ unsigned TermAlgebra::getSubtermPredicate() { void TermAlgebra::getTypeSub(Term* sort, Substitution& subst) { - CALL("TermAlgebra::getTypeSub"); auto t = _sort.term(); ASS_EQ(sort->functor(), t->functor()); for (unsigned i = 0; i < sort->arity(); i++) { diff --git a/Shell/TheoryAxioms.cpp b/Shell/TheoryAxioms.cpp index e7a820f3b..d62d04399 100644 --- a/Shell/TheoryAxioms.cpp +++ b/Shell/TheoryAxioms.cpp @@ -47,8 +47,6 @@ using namespace Shell; */ void TheoryAxioms::addAndOutputTheoryUnit(Unit* unit, unsigned level) { - CALL("TheoryAxioms::addAndOutputTheoryUnit"); - static Options::TheoryAxiomLevel opt_level = env.options->theoryAxioms(); // if the theory axioms are some or off (want this case for some things like fool) and the axiom is not // a cheap one then don't add it @@ -77,7 +75,6 @@ void TheoryAxioms::addAndOutputTheoryUnit(Unit* unit, unsigned level) */ void TheoryAxioms::addTheoryClauseFromLits(std::initializer_list lits, InferenceRule rule, unsigned level) { - CALL("TheoryAxioms::addTheoryClauseFromLits"); LiteralStack lit_stack; for (Literal* lit : lits) { ASS(lit); @@ -94,7 +91,6 @@ void TheoryAxioms::addTheoryClauseFromLits(std::initializer_list lits, */ void TheoryAxioms::addCommutativity(Interpretation op) { - CALL("TheoryAxioms::addCommutativity"); ASS(theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -115,7 +111,6 @@ void TheoryAxioms::addCommutativity(Interpretation op) */ void TheoryAxioms::addAssociativity(Interpretation op) { - CALL("TheoryAxioms::addCommutativity"); ASS(theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -140,7 +135,6 @@ void TheoryAxioms::addAssociativity(Interpretation op) */ void TheoryAxioms::addRightIdentity(Interpretation op, TermList e) { - CALL("TheoryAxioms::addRightIdentity"); ASS(theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -157,7 +151,6 @@ void TheoryAxioms::addRightIdentity(Interpretation op, TermList e) */ void TheoryAxioms::addLeftIdentity(Interpretation op, TermList e) { - CALL("TheoryAxioms::addLeftIdentity"); ASS(theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -183,8 +176,6 @@ void TheoryAxioms::addLeftIdentity(Interpretation op, TermList e) */ void TheoryAxioms::addCommutativeGroupAxioms(Interpretation op, Interpretation inverse, TermList e) { - CALL("TheoryAxioms::addCommutativeGroupAxioms"); - ASS(theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); ASS(theory->isFunction(inverse)); @@ -241,8 +232,6 @@ void TheoryAxioms::addRightInverse(Interpretation op, Interpretation inverse) */ void TheoryAxioms::addNonReflexivity(Interpretation op) { - CALL("TheoryAxioms::addNonReflexivity"); - ASS(!theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -257,7 +246,6 @@ void TheoryAxioms::addNonReflexivity(Interpretation op) */ void TheoryAxioms::addTransitivity(Interpretation op) { - CALL("TheoryAxioms::addTransitivity"); ASS(!theory->isFunction(op)); ASS_EQ(theory->getArity(op),2); @@ -278,7 +266,6 @@ void TheoryAxioms::addTransitivity(Interpretation op) */ void TheoryAxioms::addOrderingTotality(Interpretation less) { - CALL("TheoryAxioms::addOrderingTotality"); ASS(!theory->isFunction(less)); ASS_EQ(theory->getArity(less),2); @@ -300,8 +287,6 @@ void TheoryAxioms::addOrderingTotality(Interpretation less) */ void TheoryAxioms::addTotalOrderAxioms(Interpretation less) { - CALL("TheoryAxioms::addTotalOrderAxioms"); - addNonReflexivity(less); addTransitivity(less); addOrderingTotality(less); @@ -312,7 +297,6 @@ void TheoryAxioms::addTotalOrderAxioms(Interpretation less) */ void TheoryAxioms::addMonotonicity(Interpretation less, Interpretation addition) { - CALL("TheoryAxioms::addMonotonicity"); ASS(!theory->isFunction(less)); ASS_EQ(theory->getArity(less),2); ASS(theory->isFunction(addition)); @@ -339,7 +323,6 @@ void TheoryAxioms::addMonotonicity(Interpretation less, Interpretation addition) void TheoryAxioms::addPlusOneGreater(Interpretation plus, TermList oneElement, Interpretation less) { - CALL("TheoryAxioms::addPlusOneGreater"); ASS(!theory->isFunction(less)); ASS_EQ(theory->getArity(less),2); ASS(theory->isFunction(plus)); @@ -360,8 +343,6 @@ void TheoryAxioms::addPlusOneGreater(Interpretation plus, TermList oneElement, void TheoryAxioms::addAdditionAndOrderingAxioms(Interpretation plus, Interpretation unaryMinus, TermList zeroElement, TermList oneElement, Interpretation less) { - CALL("TheoryAxioms::addAdditionAndOrderingAxioms"); - addCommutativeGroupAxioms(plus, unaryMinus, zeroElement); addTotalOrderAxioms(less); addMonotonicity(less, plus); @@ -392,8 +373,6 @@ void TheoryAxioms::addAdditionAndOrderingAxioms(Interpretation plus, Interpretat void TheoryAxioms::addAdditionOrderingAndMultiplicationAxioms(Interpretation plus, Interpretation unaryMinus, TermList zeroElement, TermList oneElement, Interpretation less, Interpretation multiply) { - CALL("TheoryAxioms::addAdditionOrderingAndMultiplicationAxioms"); - TermList srt = theory->getOperationSort(plus); ASS_EQ(srt, theory->getOperationSort(unaryMinus)); ASS_EQ(srt, theory->getOperationSort(less)); @@ -451,9 +430,6 @@ void TheoryAxioms::addIntegerDivisionWithModuloAxioms(Interpretation plus, Inter Interpretation modulo, Interpretation abs, TermList zeroElement, TermList oneElement) { - CALL("TheoryAxioms::addIntegerDivisionWithModuloAxioms"); - - TermList srt = theory->getOperationSort(plus); ASS_EQ(srt, theory->getOperationSort(unaryMinus)); ASS_EQ(srt, theory->getOperationSort(less)); @@ -506,8 +482,6 @@ void TheoryAxioms::addIntegerDivisionWithModuloAxioms(Interpretation plus, Inter void TheoryAxioms::addIntegerDividesAxioms(Interpretation divides, Interpretation multiply, TermList zero, TermList n) { - CALL("TheoryAxioms::addIntegerDividesAxioms"); - #if VDEBUG // ASSERT n>0 ASS(theory->isInterpretedConstant(n)); @@ -550,8 +524,6 @@ void TheoryAxioms::addIntegerDividesAxioms(Interpretation divides, Interpretatio void TheoryAxioms::addIntegerAbsAxioms(Interpretation abs, Interpretation less, Interpretation unaryMinus, TermList zeroElement) { - CALL("TheoryAxioms::addIntegerAbsAxioms"); - TermList srt = theory->getOperationSort(abs); ASS_EQ(srt, theory->getOperationSort(less)); ASS_EQ(srt, theory->getOperationSort(unaryMinus)); @@ -585,8 +557,6 @@ void TheoryAxioms::addIntegerAbsAxioms(Interpretation abs, Interpretation less, void TheoryAxioms::addQuotientAxioms(Interpretation quotient, Interpretation multiply, TermList zeroElement, TermList oneElement, Interpretation less) { - CALL("TheoryAxioms::addQuotientAxioms"); - TermList srt = theory->getOperationSort(quotient); ASS_EQ(srt, theory->getOperationSort(multiply)); ASS_EQ(srt, theory->getOperationSort(less)); @@ -630,8 +600,6 @@ void TheoryAxioms::addQuotientAxioms(Interpretation quotient, Interpretation mul void TheoryAxioms::addExtraIntegerOrderingAxiom(Interpretation plus, TermList oneElement, Interpretation less) { - CALL("TheoryAxioms::addExtraIntegerOrderingAxiom"); - unsigned lessPred = env.signature->getInterpretingSymbol(less); unsigned plusFun = env.signature->getInterpretingSymbol(plus); TermList x(0,false); @@ -650,8 +618,6 @@ void TheoryAxioms::addExtraIntegerOrderingAxiom(Interpretation plus, TermList on void TheoryAxioms::addFloorAxioms(Interpretation floor, Interpretation less, Interpretation unaryMinus, Interpretation plus, TermList oneElement) { - CALL("TheoryAxioms::addFloorAxioms"); - unsigned lessPred = env.signature->getInterpretingSymbol(less); unsigned plusFun = env.signature->getInterpretingSymbol(plus); unsigned umFun = env.signature->getInterpretingSymbol(unaryMinus); @@ -679,8 +645,6 @@ void TheoryAxioms::addFloorAxioms(Interpretation floor, Interpretation less, Int void TheoryAxioms::addCeilingAxioms(Interpretation ceiling, Interpretation less, Interpretation plus, TermList oneElement) { - CALL("TheoryAxioms::addCeilingAxioms"); - unsigned lessPred = env.signature->getInterpretingSymbol(less); unsigned plusFun = env.signature->getInterpretingSymbol(plus); unsigned ceilingFun = env.signature->getInterpretingSymbol(ceiling); @@ -704,8 +668,6 @@ void TheoryAxioms::addCeilingAxioms(Interpretation ceiling, Interpretation less, */ void TheoryAxioms::addRoundAxioms(Interpretation round, Interpretation floor, Interpretation ceiling) { - CALL("TheoryAxioms::addRoundAxioms"); - //TODO... not that interesting as $round not in TPTP or translations // Suggested axioms: // round(x) = floor(x) | round(x) = ceiling(x) @@ -734,8 +696,6 @@ void TheoryAxioms::addRoundAxioms(Interpretation round, Interpretation floor, In void TheoryAxioms::addTruncateAxioms(Interpretation truncate, Interpretation less, Interpretation unaryMinus, Interpretation plus, TermList zeroElement, TermList oneElement) { - CALL("TheoryAxioms::addTruncateAxioms"); - unsigned lessPred = env.signature->getInterpretingSymbol(less); unsigned plusFun = env.signature->getInterpretingSymbol(plus); unsigned umFun = env.signature->getInterpretingSymbol(unaryMinus); @@ -780,8 +740,6 @@ void TheoryAxioms::addTruncateAxioms(Interpretation truncate, Interpretation les */ void TheoryAxioms::addArrayExtensionalityAxioms(TermList arraySort, unsigned skolemFn) { - CALL("TheoryAxioms::addArrayExtenstionalityAxioms"); - unsigned sel = env.signature->getInterpretingSymbol(Theory::ARRAY_SELECT,Theory::getArrayOperatorType(arraySort,Theory::ARRAY_SELECT)); TermList rangeSort = SortHelper::getInnerSort(arraySort); @@ -807,8 +765,6 @@ void TheoryAxioms::addArrayExtensionalityAxioms(TermList arraySort, unsigned sko */ void TheoryAxioms::addBooleanArrayExtensionalityAxioms(TermList arraySort, unsigned skolemFn) { - CALL("TheoryAxioms::addBooleanArrayExtenstionalityAxioms"); - OperatorType* selectType = Theory::getArrayOperatorType(arraySort,Theory::ARRAY_BOOL_SELECT); unsigned sel = env.signature->getInterpretingSymbol(Theory::ARRAY_BOOL_SELECT,selectType); @@ -837,8 +793,6 @@ void TheoryAxioms::addBooleanArrayExtensionalityAxioms(TermList arraySort, unsig */ void TheoryAxioms::addArrayWriteAxioms(TermList arraySort) { - CALL("TheoryAxioms::addArrayWriteAxioms"); - unsigned func_select = env.signature->getInterpretingSymbol(Theory::ARRAY_SELECT,Theory::getArrayOperatorType(arraySort,Theory::ARRAY_SELECT)); unsigned func_store = env.signature->getInterpretingSymbol(Theory::ARRAY_STORE,Theory::getArrayOperatorType(arraySort,Theory::ARRAY_STORE)); @@ -873,8 +827,6 @@ void TheoryAxioms::addArrayWriteAxioms(TermList arraySort) */ void TheoryAxioms::addBooleanArrayWriteAxioms(TermList arraySort) { - CALL("TheoryAxioms::addArrayWriteAxioms"); - unsigned pred_select = env.signature->getInterpretingSymbol(Theory::ARRAY_BOOL_SELECT,Theory::getArrayOperatorType(arraySort,Theory::ARRAY_BOOL_SELECT)); unsigned func_store = env.signature->getInterpretingSymbol(Theory::ARRAY_STORE,Theory::getArrayOperatorType(arraySort,Theory::ARRAY_STORE)); @@ -936,7 +888,6 @@ void TheoryAxioms::addBooleanArrayWriteAxioms(TermList arraySort) */ void TheoryAxioms::apply() { - CALL("TheoryAxioms::applyProperty"); Property* prop = _prb.getProperty(); bool modified = false; bool haveIntPlus = @@ -1135,8 +1086,6 @@ void TheoryAxioms::apply() } // TheoryAxioms::apply void TheoryAxioms::applyFOOL() { - CALL("TheoryAxioms::applyFOOL"); - TermList t(Term::foolTrue()); TermList f(Term::foolFalse()); @@ -1171,8 +1120,6 @@ void TheoryAxioms::applyFOOL() { * of the exhaustiveness axiom formula depending on the value of some magic constants. */ void TheoryAxioms::addExhaustivenessAxiom(TermAlgebra* ta) { - CALL("TheoryAxioms::addExhaustivenessAxiom"); - TermList x(0, false); TermStack typeVars; for (unsigned i = 0; i < ta->nTypeArgs(); i++) { @@ -1239,8 +1186,6 @@ void TheoryAxioms::addExhaustivenessAxiom(TermAlgebra* ta) { } void TheoryAxioms::addDistinctnessAxiom(TermAlgebra* ta) { - CALL("TermAlgebra::addDistinctnessAxiom"); - Array terms(ta->nConstructors()); unsigned var = 0; @@ -1269,8 +1214,6 @@ void TheoryAxioms::addDistinctnessAxiom(TermAlgebra* ta) { void TheoryAxioms::addInjectivityAxiom(TermAlgebra* ta) { - CALL("TheoryAxioms::addInjectivityAxiom"); - TermStack typeVars; unsigned var = 0; for (unsigned i = 0; i < ta->nTypeArgs(); i++) { @@ -1301,8 +1244,6 @@ void TheoryAxioms::addInjectivityAxiom(TermAlgebra* ta) } void TheoryAxioms::addDiscriminationAxiom(TermAlgebra* ta) { - CALL("addDiscriminationAxiom"); - TermStack args(ta->nTypeArgs()); unsigned v = 0; for (unsigned i = 0; i < ta->nTypeArgs(); i++) { @@ -1337,8 +1278,6 @@ void TheoryAxioms::addDiscriminationAxiom(TermAlgebra* ta) { void TheoryAxioms::addAcyclicityAxiom(TermAlgebra* ta) { - CALL("TheoryAxioms::addAcyclicityAxiom"); - unsigned pred = ta->getSubtermPredicate(); if (ta->allowsCyclicTerms()) { @@ -1371,8 +1310,6 @@ void TheoryAxioms::addAcyclicityAxiom(TermAlgebra* ta) bool TheoryAxioms::addSubtermDefinitions(unsigned subtermPredicate, TermAlgebraConstructor* c) { - CALL("TheoryAxioms::addSubtermDefinitions"); - TermList z(c->arity(), false); TermStack typeVars; diff --git a/Shell/TheoryFinder.cpp b/Shell/TheoryFinder.cpp index 971b2dc9e..8fa129026 100644 --- a/Shell/TheoryFinder.cpp +++ b/Shell/TheoryFinder.cpp @@ -19,7 +19,6 @@ // #include "CodeGenerator.hpp" -#include "Debug/Tracer.hpp" #include "Kernel/Clause.hpp" #include "Kernel/Formula.hpp" @@ -46,7 +45,6 @@ TheoryFinder::TheoryFinder (const UnitList* units,Property* property) : _units(units), _property(property) { - CALL("TheoryFinder::TheoryFinder"); } // TheoryFinder::TheoryFinder /** @@ -54,7 +52,6 @@ TheoryFinder::TheoryFinder (const UnitList* units,Property* property) */ TheoryFinder::~TheoryFinder () { - CALL("TheoryFinder::~TheoryFinder"); } // TheoryFinder::TheoryFinder /** @@ -63,8 +60,6 @@ TheoryFinder::~TheoryFinder () */ int TheoryFinder::search() { - CALL("TheoryFinder::search"); - int found = 0; UnitList::Iterator uit(_units); while (uit.hasNext()) { @@ -85,8 +80,6 @@ int TheoryFinder::search() */ bool TheoryFinder::matchAll(const Unit* unit) { - CALL("TheoryFinder::matchAll(const Unit*)"); - // do not remove this, we need a pointer to an existing unit if (unit->isClause()) { return matchAll(static_cast(unit)); @@ -103,8 +96,6 @@ bool TheoryFinder::matchAll(const Unit* unit) */ bool TheoryFinder::matchAll(const Clause* clause) { - CALL("TheoryFinder::matchAll(const Clause*)"); - switch (clause->length()) { case 1: return matchAll((*clause)[0]); @@ -131,8 +122,6 @@ bool TheoryFinder::matchAll(const Clause* clause) */ bool TheoryFinder::matchAll(const Formula* formula) { - CALL("TheoryFinder::matchAll (const Formula*...)"); - while (formula->connective() == FORALL) { formula = formula->qarg(); } @@ -165,8 +154,6 @@ bool TheoryFinder::matchCode(const void* obj, const unsigned char* code, uint64_t prop) { - CALL("TheoryFinder::matchCode/3"); - bool found = matchCode(obj, code); if (found && prop) { _property->addProp(prop); @@ -186,8 +173,6 @@ bool TheoryFinder::matchCode(const void* obj, bool TheoryFinder::matchCode(const void* obj, const unsigned char* code) { - CALL("TheoryFinder::matchCode/2"); - Backtrack backtrack[20]; unsigned backtrackPos = 0; @@ -712,8 +697,6 @@ bool TheoryFinder::matchCode(const void* obj, */ bool TheoryFinder::matchC(const Literal* lit) { - CALL("TheoryFinder::matchC"); - #if TRACE_FINDER cout << lit->toString() << "\n"; #endif @@ -740,7 +723,6 @@ bool TheoryFinder::matchC(const Literal* lit) */ bool TheoryFinder::matchA(const Literal* lit) { - CALL("TheoryFinder::matchA"); static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,OLDFUN,0, @@ -766,8 +748,6 @@ bool TheoryFinder::matchA(const Literal* lit) */ bool TheoryFinder::matchExtensionality (const Clause* c) { - CALL("TheoryFinder::matchExtensionality (const Clause&...)"); - static const unsigned char code[] = {CLS, NLIT,0, @@ -796,8 +776,6 @@ bool TheoryFinder::matchExtensionality (const Clause* c) */ bool TheoryFinder::matchCondensedDetachment1(const Clause* c) { - CALL("TheoryFinder::CondensedDetachment1(const LiteralList&...)"); - static const unsigned char code[] = {CLS, PLIT,0, @@ -824,8 +802,6 @@ bool TheoryFinder::matchCondensedDetachment1(const Clause* c) */ bool TheoryFinder::matchCondensedDetachment2(const Clause* c) { - CALL("TheoryFinder::CondensedDetachment2(const Clause&...)"); - static const unsigned char code[] = {CLS, PLIT,0, @@ -853,8 +829,6 @@ bool TheoryFinder::matchCondensedDetachment2(const Clause* c) */ bool TheoryFinder::matchFLD1(const Clause* c) { - CALL("TheoryFinder::matchFLD1(const Clause&...)"); - static const unsigned char code[] = {CLS, PLIT,0, @@ -887,8 +861,6 @@ bool TheoryFinder::matchFLD1(const Clause* c) */ bool TheoryFinder::matchFLD2(const Clause* c) { - CALL("TheoryFinder::matchFLD2(const Clause&...)"); - static const unsigned char code[] = {CLS, PLIT,0, @@ -916,8 +888,6 @@ bool TheoryFinder::matchFLD2(const Clause* c) */ bool TheoryFinder::matchSubset (const Clause* c) { - CALL("TheoryFinder::matchSubset(const Clause* c)"); - static const unsigned char code[] = {CLS, PLIT,0, @@ -944,8 +914,6 @@ bool TheoryFinder::matchSubset (const Clause* c) */ bool TheoryFinder::matchSubset (const Formula* f) { - CALL("TheoryFinder::matchSubset(const Formula* f)"); - static const unsigned char code[] = {CIFF, // <=> POS,NEWPRED,0,2,NEWVAR,0,NEWVAR,1, // subset(x,y) @@ -980,7 +948,6 @@ bool TheoryFinder::matchSubset (const Formula* f) */ bool TheoryFinder::matchListConstructors (const Formula* f) { - CALL("TheoryFinder::matchListConstructors"); #if TRACE_FINDER cout << "M: [match list constructors axiom]\n"; #endif @@ -1020,8 +987,6 @@ bool TheoryFinder::matchListConstructors (const Formula* f) */ bool TheoryFinder::matchExtensionality (const Formula* f) { - CALL("TheoryFinder::matchExtensionality (const Formula&...)"); - static const unsigned char code1[] = {CIFF, // <=> CFORALL,1,0,NBCIFF, // (Ax0)<=> @@ -1055,8 +1020,6 @@ bool TheoryFinder::matchExtensionality (const Formula* f) */ bool TheoryFinder::matchLeftInverse(const Literal* lit) { - CALL("TheoryFinder::matchLeftInverse"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWFUN,1,1,NEWVAR,0,OLDVAR,0, // *(i(x0),x0) @@ -1079,8 +1042,6 @@ bool TheoryFinder::matchLeftInverse(const Literal* lit) */ bool TheoryFinder::matchRightInverse(const Literal* lit) { - CALL("TheoryFinder::matchRightInverse"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWVAR,0,NEWFUN,1,1,OLDVAR,0,// *(x0,i(x0)) @@ -1103,8 +1064,6 @@ bool TheoryFinder::matchRightInverse(const Literal* lit) */ bool TheoryFinder::matchLeftIdentity(const Literal* lit) { - CALL("TheoryFinder::matchLeftIdentity"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWFUN,1,0,NEWVAR,0, // *(1,x) @@ -1127,8 +1086,6 @@ bool TheoryFinder::matchLeftIdentity(const Literal* lit) */ bool TheoryFinder::matchIdempotence(const Literal* lit) { - CALL("TheoryFinder::matchIdempotence"); - static const unsigned char code[] = {EQL,NEWFUN1,0,2,NEWVAR,0,OLDVAR,0, OLDVAR1,0,END}; // =(*(x0,x0),x0) @@ -1149,8 +1106,6 @@ bool TheoryFinder::matchIdempotence(const Literal* lit) */ bool TheoryFinder::matchRightIdentity(const Literal* lit) { - CALL("TheoryFinder::matchRightIdentity"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWVAR,0,NEWFUN,1,0, // *(x,1) @@ -1173,8 +1128,6 @@ bool TheoryFinder::matchRightIdentity(const Literal* lit) */ bool TheoryFinder::matchAssociator(const Literal* lit) { - CALL("TheoryFinder::matchAssociator"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,3,NEWVAR,0,NEWVAR,1,NEWVAR,2, // A(x0,x1,x2) @@ -1198,8 +1151,6 @@ bool TheoryFinder::matchAssociator(const Literal* lit) */ bool TheoryFinder::matchCommutator(const Literal* lit) { - CALL("TheoryFinder::matchCommutator"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,3,NEWVAR,0,NEWVAR,1, // C(x0,x1) @@ -1223,8 +1174,6 @@ bool TheoryFinder::matchCommutator(const Literal* lit) */ bool TheoryFinder::matchLeftDistributivity(const Literal* lit) { - CALL("TheoryFinder::matchLeftDistributivity"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWFUN,1,2,NEWVAR,0, @@ -1248,8 +1197,6 @@ bool TheoryFinder::matchLeftDistributivity(const Literal* lit) */ bool TheoryFinder::matchRightDistributivity (const Literal* lit) { - CALL("TheoryFinder::matchRightDistributivity"); - static const unsigned char code[] = {EQL, // // = NEWFUN1,0,2,NEWVAR,0,NEWFUN,1,2, @@ -1273,8 +1220,6 @@ bool TheoryFinder::matchRightDistributivity (const Literal* lit) */ bool TheoryFinder::matchRobbins(const Literal* lit) { - CALL("TheoryFinder::matchRobbins"); - static const unsigned char code1[] = {EQL, // // = NEWFUN1,0,1,NEWFUN,1,2,OLDFUN,0,OLDFUN,1,NEWVAR,0,NEWVAR,1,// n(+(n(+(x0,x1)), @@ -1317,8 +1262,6 @@ bool TheoryFinder::matchRobbins(const Literal* lit) */ bool TheoryFinder::matchAlternative(const Literal* lit) { - CALL("TheoryFinder::matchAlternative"); - static const unsigned char code1[] = {EQL, // // = NEWFUN1,0,2,OLDFUN,0,NEWVAR,0,OLDVAR,0,NEWVAR,1, // *(*(x0,x0),x1) @@ -1345,8 +1288,6 @@ bool TheoryFinder::matchAlternative(const Literal* lit) */ bool TheoryFinder::matchAbsorption(const Literal* lit) { - CALL("TheoryFinder::matchAbsorption"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,NEWVAR,0,NEWFUN,1,2,OLDVAR,0,NEWVAR,1, // *(x0,+(x0,x1)) @@ -1369,8 +1310,6 @@ bool TheoryFinder::matchAbsorption(const Literal* lit) */ bool TheoryFinder::matchCombinatorS(const Literal* lit) { - CALL("TheoryFinder::matchCombinatorS"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,OLDFUN,0,OLDFUN,0,NEWFUN,1,0, @@ -1395,8 +1334,6 @@ bool TheoryFinder::matchCombinatorS(const Literal* lit) */ bool TheoryFinder::matchCombinatorB(const Literal* lit) { - CALL("TheoryFinder::matchCombinatorB"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,OLDFUN,0,OLDFUN,0,NEWFUN,1,0, @@ -1420,8 +1357,6 @@ bool TheoryFinder::matchCombinatorB(const Literal* lit) */ bool TheoryFinder::matchCombinatorT(const Literal* lit) { - CALL("TheoryFinder::matchCombinatorT"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,OLDFUN,0,NEWFUN,1,0,NEWVAR,0,NEWVAR,1, // _(_(T,x0),x1) @@ -1444,8 +1379,6 @@ bool TheoryFinder::matchCombinatorT(const Literal* lit) */ bool TheoryFinder::matchCombinatorO(const Literal* lit) { - CALL("TheoryFinder::matchCombinatorO"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,OLDFUN,0,NEWFUN,1,0,NEWVAR,0,NEWVAR,1, // _(_(O,x0),x1) @@ -1468,8 +1401,6 @@ bool TheoryFinder::matchCombinatorO(const Literal* lit) */ bool TheoryFinder::matchCombinatorQ(const Literal* lit) { - CALL("TheoryFinder::matchCombinatorQ"); - static const unsigned char code[] = {EQL, // = NEWFUN1,0,2,OLDFUN,0,OLDFUN,0,NEWFUN,1,0, @@ -1492,8 +1423,6 @@ bool TheoryFinder::matchCombinatorQ(const Literal* lit) */ bool TheoryFinder::matchAll (const Literal* lit) { - CALL("TheoryFinder::matchAll(const Literal*)"); - if (! lit->isPositive()) { return false; } @@ -1525,8 +1454,6 @@ bool TheoryFinder::matchAll (const Literal* lit) // */ // void TheoryFinder::analyse (const Clause& clause) // { -// CALL("TheoryFinder::analyse"); - // const Term& answer = clause.literals().head().atom().args().head(); // const vstring theory(answer.functor().name()); // if (theory == "group") { diff --git a/Shell/TheoryFlattening.cpp b/Shell/TheoryFlattening.cpp index dadd9f220..837d08266 100644 --- a/Shell/TheoryFlattening.cpp +++ b/Shell/TheoryFlattening.cpp @@ -43,8 +43,6 @@ TheoryFlattening::TheoryFlattening(bool rec, bool share) : _recursive(rec), _sha void TheoryFlattening::apply(Problem& prb) { - CALL("TheoryFlattening::apply(Problem&)"); - if(apply(prb.units())) { prb.invalidateProperty(); } @@ -55,8 +53,6 @@ void TheoryFlattening::apply(Problem& prb) */ bool TheoryFlattening::apply(UnitList*& units) { - CALL("TheoryFlattening::apply(UnitList*&)"); - bool modified = false; UnitList* res=0; @@ -83,8 +79,6 @@ bool TheoryFlattening::apply(UnitList*& units) */ bool TheoryFlattening::apply(ClauseList*& clauses) { - CALL("TheoryFlattening::apply(UnitList*&)"); - bool modified = false; ClauseList* res=0; @@ -110,8 +104,6 @@ bool TheoryFlattening::apply(ClauseList*& clauses) */ Clause* TheoryFlattening::apply(Clause*& cl,Stack& target) { - CALL("TheoryFlattening::apply"); - // Find the max variable. This will be used to introduce new variables. unsigned maxVar = 0; VirtualIterator varIt = cl->getVariableIterator(); @@ -180,7 +172,6 @@ Clause* TheoryFlattening::apply(Clause*& cl,Stack& target) Literal* TheoryFlattening::replaceTopTerms(Literal* lit, Stack& newLits,unsigned& maxVar, DHMap& abstracted) { - CALL("TheoryFlattening::replaceTopTerms"); //cout << "replaceTopTerms " << lit->toString() << endl; // Tells us if we're looking for interpreted are non-interpreted terms to flatten out @@ -268,7 +259,6 @@ Clause* TheoryFlattening::apply(Clause*& cl,Stack& target) unsigned& maxVar,bool interpreted, DHMap& abstracted) { - CALL("TheoryFlattening::replaceTopTermsInTerm"); //cout << "replaceTopTermsInTerm " << term->toString() << endl; diff --git a/Shell/TweeGoalTransformation.cpp b/Shell/TweeGoalTransformation.cpp index fb8a83d76..8f0c353d6 100644 --- a/Shell/TweeGoalTransformation.cpp +++ b/Shell/TweeGoalTransformation.cpp @@ -72,8 +72,6 @@ class Definizator : public BottomUpTermTransformer { // a helper function to collect terms variables and their sorts // all stored in the above private fields to be looked up by transformSubterm void scanVars(Term* t) { - CALL("Definizator::scanVars"); - static DHSet varSeen; varSeen.reset(); _typeArity = 0; @@ -109,8 +107,6 @@ class Definizator : public BottomUpTermTransformer { protected: TermList transformSubterm(TermList trm) override { - CALL("Definizator::transformSubterm"); - // cout << "tf: " << trm.toString() << endl; if (trm.isVar()) return trm; Term* t = trm.term(); @@ -185,8 +181,6 @@ class Definizator : public BottomUpTermTransformer { void Shell::TweeGoalTransformation::apply(Problem &prb, bool groundOnly) { - CALL("TweeGoalTransformation::apply"); - Stack newLits; Definizator df(groundOnly); diff --git a/Shell/UIHelper.cpp b/Shell/UIHelper.cpp index 2293e5ec3..189505cb2 100644 --- a/Shell/UIHelper.cpp +++ b/Shell/UIHelper.cpp @@ -144,8 +144,6 @@ bool UIHelper::spiderOutputDone = false; void UIHelper::outputAllPremises(ostream& out, UnitList* units, vstring prefix) { - CALL("UIHelper::outputAllPremises"); - #if 1 InferenceStore::instance()->outputProof(cerr, units); #else @@ -186,8 +184,6 @@ void UIHelper::outputAllPremises(ostream& out, UnitList* units, vstring prefix) void UIHelper::outputSaturatedSet(ostream& out, UnitIterator uit) { - CALL("UIHelper::outputSaturatedSet"); - addCommentSignForSZS(out); out << "# SZS output start Saturation." << endl; @@ -271,8 +267,6 @@ void resetParsing(T exception, vstring inputFile, istream*& input,vstring nowtry */ Problem* UIHelper::getInputProblem(const Options& opts) { - CALL("UIHelper::getInputProblem"); - TIME_TRACE(TimeTrace::PARSING); env.statistics->phase = Statistics::PARSING; @@ -384,8 +378,6 @@ Problem* UIHelper::getInputProblem(const Options& opts) */ void UIHelper::outputResult(ostream& out) { - CALL("UIHelper::outputResult"); - switch (env.statistics->terminationReason) { case Statistics::REFUTATION: if(env.options->outputMode() == Options::Output::SMTCOMP){ @@ -534,8 +526,6 @@ void UIHelper::outputResult(ostream& out) void UIHelper::outputSatisfiableResult(ostream& out) { - CALL("UIHelper::outputSatisfiableResult"); - //out << "Satisfiable!\n"; if (szsOutputMode() && !satisfiableStatusWasAlreadyOutput) { out << "% SZS status " << ( UIHelper::haveConjecture() ? "CounterSatisfiable" : "Satisfiable" ) @@ -567,8 +557,6 @@ void UIHelper::outputSatisfiableResult(ostream& out) */ void UIHelper::outputSymbolDeclarations(ostream& out) { - CALL("UIHelper::outputSymbolDeclarations"); - Signature& sig = *env.signature; unsigned typeCons = sig.typeCons(); @@ -598,8 +586,6 @@ void UIHelper::outputSymbolDeclarations(ostream& out) */ void UIHelper::outputSymbolTypeDeclarationIfNeeded(ostream& out, bool function, bool typeCon, unsigned symNumber) { - CALL("UIHelper::outputSymbolTypeDeclarationIfNeeded"); - Signature::Symbol* sym; if(function){ diff --git a/Shell/VarManager.cpp b/Shell/VarManager.cpp index ef4ead5a4..53f7becb6 100644 --- a/Shell/VarManager.cpp +++ b/Shell/VarManager.cpp @@ -13,7 +13,6 @@ */ #include "Debug/Assertion.hpp" -#include "Debug/Tracer.hpp" #include "VarManager.hpp" @@ -26,7 +25,6 @@ VarManager::VarFactory* VarManager::_fact = 0; unsigned VarManager::getVarAlias(unsigned var) { - CALL("VarManager::getVarAlias"); ASS(_fact); return _fact->getVarAlias(var); @@ -34,7 +32,6 @@ unsigned VarManager::getVarAlias(unsigned var) vstring VarManager::getVarName(unsigned var) { - CALL("VarManager::getVarName"); ASS(_fact); return _fact->getVarName(var); diff --git a/Test/SyntaxSugar.hpp b/Test/SyntaxSugar.hpp index b2dd4455b..94a3a6ddc 100644 --- a/Test/SyntaxSugar.hpp +++ b/Test/SyntaxSugar.hpp @@ -548,7 +548,6 @@ class FuncSugar { } FuncSugar dtor(unsigned i) const { - CALL("FuncSugar::dtor(unsigned)") ASS_L(i, arity()) ASS (symbol()->termAlgebraCons()) return FuncSugar( diff --git a/Test/UnitTesting.cpp b/Test/UnitTesting.cpp index ba4254e49..de559f9e5 100644 --- a/Test/UnitTesting.cpp +++ b/Test/UnitTesting.cpp @@ -14,7 +14,6 @@ #include #include -#include "Debug/Tracer.hpp" #include "Lib/Sys/Multiprocessing.hpp" @@ -125,7 +124,6 @@ bool TestUnit::run(ostream& out) out.flush(); bool ok; { - CALL(t.name); ok = spawnTest(t.proc); } out << "\r" << ( ok ? "[ OK ]" : "[ FAIL ]" ) << " " << t.name << " " << endl; @@ -198,7 +196,6 @@ std::ostream& operator<<(ostream& out, TestUnit::Test const& t) int main(int argc, const char** argv) { - CALL("UnitTesting::main") using namespace Lib; using namespace std; bool success; diff --git a/Test/UnitTesting.hpp b/Test/UnitTesting.hpp index 996270bb2..7d7040ccd 100644 --- a/Test/UnitTesting.hpp +++ b/Test/UnitTesting.hpp @@ -21,7 +21,6 @@ #include "Forwards.hpp" #include "Lib/Stack.hpp" -#include "Debug/Tracer.hpp" #include "Lib/VString.hpp" diff --git a/UnitTests/tInduction.cpp b/UnitTests/tInduction.cpp index 67b12fe39..213416998 100644 --- a/UnitTests/tInduction.cpp +++ b/UnitTests/tInduction.cpp @@ -1207,4 +1207,4 @@ TEST_FUN(generalizations_03) { f(f(f(ph_s,sK2),f(ph_s,ph_s)),f(f(ph_s,g(sK2)),f(f(ph_s,sK2),ph_s)))) }), }), }); -} \ No newline at end of file +} diff --git a/UnitTests/tKBO.hpp b/UnitTests/tKBO.hpp index cb3317062..52a6beecd 100644 --- a/UnitTests/tKBO.hpp +++ b/UnitTests/tKBO.hpp @@ -48,4 +48,4 @@ inline Map weights(pair... as) { Map out; __weights(out, as...); return out; -} \ No newline at end of file +} diff --git a/UnitTests/tQuotientE.cpp b/UnitTests/tQuotientE.cpp index 487b4ed6a..5cf6e77b6 100644 --- a/UnitTests/tQuotientE.cpp +++ b/UnitTests/tQuotientE.cpp @@ -7,7 +7,6 @@ * https://vprover.github.io/license.html * and in the source directory */ -#include "Debug/Tracer.hpp" #include "Test/SyntaxSugar.hpp" #include "Test/UnitTesting.hpp" diff --git a/UnitTests/tSATSolver.cpp b/UnitTests/tSATSolver.cpp index 32d40d962..e4cd6ca73 100644 --- a/UnitTests/tSATSolver.cpp +++ b/UnitTests/tSATSolver.cpp @@ -33,8 +33,6 @@ using namespace SAT; */ SATLiteral getLit(char c) { - CALL("getLit"); - bool pol; unsigned var; if(c>='a' && c<='z') { @@ -57,8 +55,6 @@ SATLiteral getLit(char c) */ SATClause* getClause(const char* spec) { - CALL("getClause"); - SATLiteralStack lits; while(*spec) { char c = *spec; @@ -78,8 +74,6 @@ void ensurePrepared(SATSolver& s) /* void testZICert1(SATSolverWithAssumptions& s) { - CALL("testZICert1"); - ensurePrepared(s); s.addClause(getClause("ab")); s.addClause(getClause("c")); @@ -112,8 +106,6 @@ TEST_FUN(satSolverZeroImpliedCert) void testProofWithAssumptions(SATSolver& s) { - CALL("testProofWithAssumptions"); - s.ensureVarCount(2); s.addClause(getClause("a")); s.addClause(getClause("A")); @@ -243,8 +235,6 @@ TEST_FUN(testSATSolverInterface) } void testAssumptions(SATSolverWithAssumptions &s) { - CALL("testAssumptions"); - ensurePrepared(s); s.addClause(getClause("ab")); diff --git a/UnitTests/tSafeRecursion.cpp b/UnitTests/tSafeRecursion.cpp index 8942c91fd..92317c97b 100644 --- a/UnitTests/tSafeRecursion.cpp +++ b/UnitTests/tSafeRecursion.cpp @@ -45,7 +45,6 @@ struct SRWorkerBase { template void pre(unsigned obj, ChildCallback fn) { - CALL("SRWorkerBase::pre"); Stack& children = getGraph()[obj]; Stack::BottomFirstIterator cit(children); while(cit.hasNext()) { @@ -59,7 +58,6 @@ struct MaxDegreeRetrievalWorker : public SRWorkerBase { int post(unsigned obj, size_t childCnt, int* childRes) { - CALL("MaxDegreeRetrievalWorker::post"); int res = childCnt; for(size_t i=0; ires) { @@ -83,7 +81,6 @@ struct StrRepWorker : public SRWorkerBase { vstring post(unsigned obj, size_t childCnt, vstring* childRes) { - CALL("MaxDegreeRetrievalWorker::post"); vstring res = Int::toString(obj); if(childCnt==0) { return res; diff --git a/UnitTests/tTwoVampires.cpp b/UnitTests/tTwoVampires.cpp index a6a6472f5..9db36b6ba 100644 --- a/UnitTests/tTwoVampires.cpp +++ b/UnitTests/tTwoVampires.cpp @@ -45,8 +45,6 @@ using namespace Shell; void runChild(UnitList* units, vstring slice) { - CALL("runChild") - int resultValue=1; try { env.timer->reset(); diff --git a/UnitTests/tZ3Interfacing.cpp b/UnitTests/tZ3Interfacing.cpp index f8002c157..b0cdb23a8 100644 --- a/UnitTests/tZ3Interfacing.cpp +++ b/UnitTests/tZ3Interfacing.cpp @@ -36,8 +36,6 @@ using FuncId = unsigned; /** runs z3 on a bunch of vampire literals as assumptions, and checks the status afterwards */ void checkStatus(SAT::Z3Interfacing& z3, SAT2FO& s2f, SATSolver::Status expected, Stack assumptions) { - CALL("checkStatus(..)") - for (auto a : assumptions) { // Stack clause{s2f.toSAT(a)}; // z3.addClause(SATClause::fromStack(clause)); @@ -210,8 +208,6 @@ TEST_FUN(solve__dty__03_03) { void checkInstantiation(SAT::Z3Interfacing& z3, SAT2FO& s2f, Stack assumptions, TermList toInstantiate, TermList expected) { - CALL("checkInstantiation(..)") - for (auto a : assumptions) { z3.addAssumption(s2f.toSAT(a)); } diff --git a/test_vapi.cpp b/test_vapi.cpp index 14322dfbc..89a31af1b 100644 --- a/test_vapi.cpp +++ b/test_vapi.cpp @@ -271,8 +271,6 @@ void readAndFilterGlobalOpts(Stack& args) { int main(int argc, char* argv []) { - CALL("main"); - Stack args; args.loadFromIterator(getArrayishObjectIterator(argv, argc)); readAndFilterGlobalOpts(args); diff --git a/vampire.cpp b/vampire.cpp index 4c13131ef..d3fb945ef 100644 --- a/vampire.cpp +++ b/vampire.cpp @@ -20,7 +20,6 @@ #include "z3++.h" #endif -#include "Debug/Tracer.hpp" #include "Lib/Exception.hpp" #include "Lib/Environment.hpp" @@ -130,8 +129,6 @@ int g_returnValue = 1; */ Problem* getPreprocessedProblem() { - CALL("getPreprocessedProblem"); - #ifdef __linux__ unsigned saveInstrLimit = env.options->instructionLimit(); if (env.options->parsingDoesNotCount()) { @@ -170,7 +167,6 @@ void explainException(Exception& exception) void getRandomStrategy() { - CALL("getRandomStrategy()"); // We might have set random_strategy sat if(env.options->randomStrategy()==Options::RandomStrategy::OFF){ env.options->setRandomStrategy(Options::RandomStrategy::ON); @@ -189,7 +185,6 @@ void getRandomStrategy() void doProving() { - CALL("doProving()"); // One call to randomize before preprocessing (see Options) env.options->randomizeStrategy(0); @@ -212,8 +207,6 @@ void doProving() */ void profileMode() { - CALL("profileMode()"); - ScopedPtr prb(UIHelper::getInputProblem(*env.options)); /* CAREFUL: Make sure that the order @@ -234,8 +227,6 @@ void profileMode() } // profileMode void outputResult(ostream& out) { - CALL("outputResult"); - switch(env.statistics->terminationReason) { case Statistics::UNKNOWN: cout<<"unknown"<latexOutput()!="off"); BYPASSING_ALLOCATOR; // not sure why we need this yet, ofstream? @@ -313,7 +303,6 @@ void outputClausesToLaTeX(Problem* prb) // print the formulas of a problem to a LaTeX file void outputProblemToLaTeX(Problem* prb) { - CALL("outputProblemToLaTeX"); ASS(env.options->latexOutput()!="off"); BYPASSING_ALLOCATOR; // not sure why we need this yet, ofstream? @@ -353,8 +342,6 @@ void outputProblemToLaTeX(Problem* prb) */ void preprocessMode(bool theory) { - CALL("preprocessMode()"); - Problem* prb = UIHelper::getInputProblem(*env.options); TIME_TRACE(TimeTrace::PREPROCESSING); @@ -409,8 +396,6 @@ void preprocessMode(bool theory) */ void modelCheckMode() { - CALL("modelCheckMode"); - env.options->setOutputAxiomNames(true); Problem* prb = UIHelper::getInputProblem(*env.options); @@ -431,8 +416,6 @@ void modelCheckMode() */ void outputMode() { - CALL("outputMode()"); - Problem* prb = UIHelper::getInputProblem(*env.options); env.beginOutput(); @@ -455,8 +438,6 @@ void outputMode() void vampireMode() { - CALL("vampireMode()"); - if (env.options->mode() == Options::Mode::CONSEQUENCE_ELIMINATION) { env.options->setUnusedPredicateDefinitionRemoval(false); } @@ -475,7 +456,6 @@ void vampireMode() void spiderMode() { - CALL("spiderMode()"); env.options->setBadOptionChoice(Options::BadOption::HARD); env.options->setOutputMode(Options::Output::SPIDER); env.options->setNormalize(true); @@ -573,8 +553,6 @@ void spiderMode() void clausifyMode(bool theory) { - CALL("clausifyMode()"); - CompositeISE simplifier; simplifier.addFront(new TrivialInequalitiesRemovalISE()); simplifier.addFront(new TautologyDeletionISE()); @@ -628,8 +606,6 @@ void clausifyMode(bool theory) void axiomSelectionMode() { - CALL("axiomSelectionMode()"); - env.options->setSineSelection(Options::SineSelection::AXIOMS); ScopedPtr prb(UIHelper::getInputProblem(*env.options)); @@ -670,8 +646,6 @@ void axiomSelectionMode() */ int main(int argc, char* argv[]) { - CALL ("main"); - System::registerArgv0(argv[0]); System::setSignalHandlers();