void OverlapIndexInsertIntoClause2(OverlapIndex_p tindex,
OverlapIndex_p naindex,
Clause_p clause)
{
PStack_p terms = PStackAlloc();
PStack_p natoms = PStackAlloc();
CompactPos pos;
Term_p term;
ClauseCollectIntoTermsPos2(clause, terms, natoms);
while(!PStackEmpty(terms))
{
pos = PStackPopInt(terms);
term = PStackPopP(terms);
OverlapIndexInsertPos(tindex, clause, pos, term);
}
while(!PStackEmpty(natoms))
{
pos = PStackPopInt(natoms);
term = PStackPopP(natoms);
OverlapIndexInsertPos(naindex, clause, pos, term);
}
PStackFree(natoms);
PStackFree(terms);
}
double sim_eqn_weight(Eqn_p eqn, SimParam_p parms)
{
double eq_weight = 0.0, clash_weight = 0.0;
PStack_p stack = PStackAlloc();
Term_p lside, rside;
int i;
lside = eqn->lterm;
rside = eqn->rterm;
PStackPushP(stack, lside);
PStackPushP(stack, rside);
while(!PStackEmpty(stack))
{
rside = PStackPopP(stack);
lside = PStackPopP(stack);
if(lside->f_code == rside->f_code)
{
eq_weight += parms->equal_weight;
for(i=0; i<lside->arity; i++)
{
PStackPushP(stack, lside->args[i]);
PStackPushP(stack, rside->args[i]);
}
}
else
{
if(TermIsVar(lside))
{
if(TermIsVar(rside))
{
clash_weight += parms->var_var_clash;
}
else
{
clash_weight += parms->var_term_clash;
}
}
else
{
if(TermIsVar(rside))
{
clash_weight += parms->var_term_clash;
}
else
{
clash_weight += parms->term_term_clash *
(TermWeight(lside, 1, 1)+TermWeight(rside, 1, 1));
}
}
}
}
PStackFree(stack);
return clash_weight;
}
static void pdtree_backtrack(PDTree_p tree, Subst_p subst)
{
PDTNode_p handle = tree->tree_pos;
bool succ;
if(handle->variable)
{
tree->term_weight += (TermStandardWeight(handle->variable->binding) -
TermStandardWeight(handle->variable));
PStackPushP(tree->term_stack, handle->variable->binding);
if(handle->bound)
{
succ = SubstBacktrackSingle(subst);
(void)succ; assert(succ);
}
}
else if(handle->parent)
{
Term_p t = PStackPopP(tree->term_proc);
(void)t; assert(t);
TermLRTraversePrev(tree->term_stack,t);
}
tree->tree_pos = handle->parent;
}
static long delete_clause_entries(PTree_p *root, Clause_p clause)
{
long res = 0;
PStack_p trav_stack;
PStack_p store = PStackAlloc();
PTree_p handle;
ClausePos_p pos;
trav_stack = PTreeTraverseInit(*root);
while((handle = PTreeTraverseNext(trav_stack)))
{
pos = handle->key;
if(pos->clause == clause)
{
PStackPushP(store, pos);
}
}
PTreeTraverseExit(trav_stack);
while(!PStackEmpty(store))
{
pos = PStackPopP(store);
PTreeDeleteEntry(root, pos);
ClausePosCellFree(pos);
res++;
}
PStackFree(store);
return res;
}
bool PTreeMerge(PTree_p *root, PTree_p add)
{
PStack_p stack = PStackAlloc();
PTree_p tmp;
bool res = false;
PStackPushP(stack, add);
while(!PStackEmpty(stack))
{
add = PStackPopP(stack);
if(add)
{
PStackPushP(stack, add->lson);
PStackPushP(stack, add->rson);
tmp = PTreeInsert(root, add);
if(tmp)
{
PTreeCellFree(add);
}
else
{
res = true;
}
}
}
PStackFree(stack);
return res;
}
void* PTreeSharedElement(PTree_p *tree1, PTree_p tree2)
{
PStack_p stack = PStackAlloc();
PTree_p handle, tmp;
void* res = NULL;
PStackPushP(stack, tree2);
while(!PStackEmpty(stack))
{
handle = PStackPopP(stack);
if(handle)
{
tmp = PTreeFind(tree1, handle->key);
if(tmp)
{
res = tmp->key;
break;
}
PStackPushP(stack,handle->lson);
PStackPushP(stack,handle->rson);
}
}
PStackFree(stack);
return res;
}
static void term_del_prop_level(Term_p term, int depth, TermProperties prop)
{
PStack_p stack = PStackAlloc();
int i;
PStackPushP(stack, term);
PStackPushInt(stack, depth);
if(depth>=0) /* Special case depth = -1 can happen -> Do nothing */
{
while(!PStackEmpty(stack))
{
depth = PStackPopInt(stack);
term = PStackPopP(stack);
TermCellDelProp(term, prop);
if(depth!=0)
{
for(i=0; i<term->arity; i++)
{
assert(!TermIsVar(term));
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, depth-1);
}
}
}
}
PStackFree(stack);
}
static void term_set_prop_at_level(Term_p term, int depth,
TermProperties prop)
{
PStack_p stack = PStackAlloc();
int i;
PStackPushP(stack, term);
PStackPushInt(stack, depth);
while(!PStackEmpty(stack))
{
depth = PStackPopInt(stack);
term = PStackPopP(stack);
if(depth!=0)
{
for(i=0; i<term->arity; i++)
{
assert(!TermIsVar(term));
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, depth-1);
}
}
else
{
TermCellSetProp(term, prop);
}
}
PStackFree(stack);
}
void VarHashAddVarDistrib(VarHash_p hash, Term_p term, DerefType
deref, long add)
{
PStack_p stack = PStackAlloc();
int i;
PStackPushP(stack, term);
PStackPushInt(stack, deref);
while(!PStackEmpty(stack))
{
deref = PStackPopInt(stack);
term = PStackPopP(stack);
term = TermDeref(term, &deref);
if(TermIsVar(term))
{
VarHashAddValue(hash, term, add);
}
else
{
for(i=0; i<term->arity; i++)
{
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, deref);
}
}
}
PStackFree(stack);
}
void TermVarDelProp(Term_p term, DerefType deref, TermProperties prop)
{
PStack_p stack = PStackAlloc();
int i;
PStackPushP(stack, term);
PStackPushInt(stack, deref);
while(!PStackEmpty(stack))
{
deref = PStackPopInt(stack);
term = PStackPopP(stack);
term = TermDeref(term, &deref);
if(TermIsVar(term))
{
TermCellDelProp(term, prop);
}
for(i=0; i<term->arity; i++)
{
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, deref);
}
}
PStackFree(stack);
}
long PTreeDebugPrint(FILE* out, PTree_p root)
{
PStack_p stack = PStackAlloc();
long res = 0;
PStackPushP(stack, root);
while(!PStackEmpty(stack))
{
root = PStackPopP(stack);
if(root)
{
if(res % 10 == 0)
{
fprintf(out, "\n#");
}
fprintf(out, " %7p", root->key);
PStackPushP(stack, root->lson);
PStackPushP(stack, root->rson);
res++;
}
}
PStackFree(stack);
fprintf(out, "\n");
return res;
}
void PDArrayAddVarDistrib(PDArray_p array, Term_p term, DerefType
deref, long add)
{
PStack_p stack = PStackAlloc();
int i;
long tmp;
PStackPushP(stack, term);
PStackPushInt(stack, deref);
while(!PStackEmpty(stack))
{
deref = PStackPopInt(stack);
term = PStackPopP(stack);
term = TermDeref(term, &deref);
if(TermIsVar(term))
{
tmp = PDArrayElementInt(array, (-(term->f_code)));
PDArrayAssignInt(array, (-(term->f_code)), tmp+add);
}
else
{
for(i=0; i<term->arity; i++)
{
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, deref);
}
}
}
PStackFree(stack);
}
bool TermVarSearchProp(Term_p term, DerefType deref, TermProperties prop)
{
PStack_p stack = PStackAlloc();
int i;
bool res = false;
PStackPushP(stack, term);
PStackPushInt(stack, deref);
while(!PStackEmpty(stack))
{
deref = PStackPopInt(stack);
term = PStackPopP(stack);
term = TermDeref(term, &deref);
if(TermIsVar(term) && TermCellQueryProp(term, prop))
{
res = true;
break;
}
for(i=0; i<term->arity; i++)
{
PStackPushP(stack, term->args[i]);
PStackPushInt(stack, deref);
}
}
PStackFree(stack);
return res;
}
void HCBAdminFree(HCBAdmin_p junk)
{
char* name;
assert(junk);
assert(junk->names);
assert(junk->hcb_set);
while(!PStackEmpty(junk->names))
{
name = PStackPopP(junk->names);
FREE(name);
}
PStackFree(junk->names);
while(!PStackEmpty(junk->hcb_set))
{
HCBFree(PStackPopP(junk->hcb_set));
}
PStackFree(junk->hcb_set);
HCBAdminCellFree(junk);
}
Term_p TermLRTraversePrev(PStack_p stack, Term_p term)
{
Term_p tmp;
int i;
for(i=0; i<term->arity; i++)
{
tmp = PStackPopP(stack);
(void)tmp; assert(tmp == term->args[i]);
}
PStackPushP(stack, term);
return term;
}
static
ClausePos_p unit_clause_set_strongsubsumes_termpair(ClauseSet_p set,
Term_p t1, Term_p t2,
bool positive)
{
PStack_p stack = PStackAlloc();
int i;
ClausePos_p res = NULL;
PStackPushP(stack, t1);
PStackPushP(stack, t2);
while(!PStackEmpty(stack))
{
t2 = PStackPopP(stack);
t1 = PStackPopP(stack);
res = FindSignedTopSimplifyingUnit(set, t1, t2, positive);
if(!res)
{
if(t1->f_code != t2->f_code || !t1->arity)
{
break;
}
for(i=0; i<t1->arity; i++)
{
if(!TBTermEqual(t1->args[i], t2->args[i]))
{
PStackPushP(stack, t1->args[i]);
PStackPushP(stack, t2->args[i]);
}
}
}
}
PStackFree(stack);
return res;
}
void OverlapIndexInsertIntoClause(OverlapIndex_p index, Clause_p clause)
{
PStack_p collector = PStackAlloc();
CompactPos pos;
Term_p term;
ClauseCollectIntoTermsPos(clause, collector);
while(!PStackEmpty(collector))
{
pos = PStackPopInt(collector);
term = PStackPopP(collector);
OverlapIndexInsertPos(index, clause, pos, term);
}
PStackFree(collector);
}
Eval_p EvalTreeTraverseNext(PStack_p state, int pos)
{
Eval_p handle, res;
if(PStackEmpty(state))
{
return NULL;
}
res = PStackPopP(state);
handle = res->evals[pos].rson;
while(handle)
{
PStackPushP(state, handle);
handle = handle->evals[pos].lson;
}
return res;
}
Term_p TermLRTraverseNext(PStack_p stack)
{
int i;
Term_p handle;
if(PStackEmpty(stack))
{
return NULL;
}
handle = PStackPopP(stack);
for(i=handle->arity-1; i>=0; i--)
{
PStackPushP(stack, handle->args[i]);
}
return handle;
}
void PTreeInsertTree(PTree_p *root, PTree_p add)
{
PStack_p stack = PStackAlloc();
PStackPushP(stack, add);
while(!PStackEmpty(stack))
{
add = PStackPopP(stack);
if(add)
{
PStackPushP(stack, add->lson);
PStackPushP(stack, add->rson);
PTreeStore(root, add->key);
}
}
PStackFree(stack);
}
Term_p TBTermPosReplace(TB_p bank, Term_p repl, TermPos_p pos,
DerefType deref)
{
Term_p handle, old;
int subscript;
PStackPointer i;
PStack_p store = PStackAlloc();
assert(bank);
assert(repl);
assert(pos);
i = PStackGetSP(pos);
/* Note that we start inside-out here - the first term handled is
the actual subterm replaced, at the end repl is the complete
term generated.*/
while(i)
{
i--;
subscript = PStackElementInt(pos, i);
assert(i);
i--;
old = PStackElementP(pos, i);
handle = TermTopCopy(old);
assert(handle->arity > subscript);
handle->args[subscript] = repl;
PStackPushP(store, handle);
repl = handle;
}
repl = TBInsertNoProps(bank, repl, deref);
while(!PStackEmpty(store))
{
handle = PStackPopP(store);
TermTopFree(handle);
}
PStackFree(store);
return repl;
}
Term_p AltTermTop(Term_p term, int depth, VarBank_p freshvars)
{
PStack_p bindings = PStackAlloc();
Term_p handle, res;
assert(TermIsShared(term));
VarBankSetVCount(freshvars, FRESH_VAR_LIMIT);
res = alt_rek_term_top(term, depth, freshvars, bindings);
while(!PStackEmpty(bindings))
{
handle = PStackPopP(bindings);
assert(handle->binding);
handle->binding = NULL;
}
PStackFree(bindings);
return res;
}
void DPLLFormulaFree(DPLLFormula_p junk)
{
int i;
for(i=0; i<junk->atom_no; i++)
{
PTreeFree(junk->atoms[i].pos_active);
PTreeFree(junk->atoms[i].neg_active);
}
FREE(junk->atoms);
while(!PStackEmpty(junk->clauses))
{
DPLLClauseFree(PStackPopP(junk->clauses));
}
PStackFree(junk->clauses);
PropSigFree(junk->sig);
DPLLFormulaCellFree(junk);
}
void FileVarsFree(FileVars_p handle)
{
PStack_p stack;
StrTree_p cell;
char* name;
while(!PStackEmpty(handle->names))
{
name = PStackPopP(handle->names);
FREE(name);
}
PStackFree(handle->names);
stack = StrTreeTraverseInit(handle->vars);
while((cell = StrTreeTraverseNext(stack)))
{
FREE(cell->val1.p_val);
}
StrTreeFree(handle->vars);
FileVarsCellFree(handle);
}
PTree_p PTreeCopy(PTree_p tree)
{
PTree_p res = NULL, handle;
PStack_p stack = PStackAlloc();
PStackPushP(stack, tree);
while(!PStackEmpty(stack))
{
handle = PStackPopP(stack);
if(handle)
{
PTreeStore(&res, handle->key);
PStackPushP(stack,handle->lson);
PStackPushP(stack,handle->rson);
}
}
PStackFree(stack);
return res;
}
long NumTreeNodes(NumTree_p root)
{
PStack_p stack = PStackAlloc();
long res = 0;
PStackPushP(stack, root);
while(!PStackEmpty(stack))
{
root = PStackPopP(stack);
if(root)
{
PStackPushP(stack, root->lson);
PStackPushP(stack, root->rson);
res++;
}
}
PStackFree(stack);
return res;
}
static long remove_subsumed(GlobalIndices_p indices,
FVPackedClause_p subsumer,
ClauseSet_p set,
ClauseSet_p archive)
{
Clause_p handle;
long res;
PStack_p stack = PStackAlloc();
res = ClauseSetFindFVSubsumedClauses(set, subsumer, stack);
while(!PStackEmpty(stack))
{
handle = PStackPopP(stack);
if(ClauseQueryProp(handle, CPWatchOnly))
{
DocClauseQuote(GlobalOut, OutputLevel, 6, handle,
"extract_wl_subsumed", subsumer->clause);
}
else
{
DocClauseQuote(GlobalOut, OutputLevel, 6, handle,
"subsumed", subsumer->clause);
}
ClauseKillChildren(handle);
GlobalIndicesDeleteClause(indices, handle);
if(BuildProofObject||ClauseIsDemodulator(handle))
{
ClauseSetExtractEntry(handle);
ClauseSetInsert(archive, handle);
}
else
{
ClauseSetDeleteEntry(handle);
}
}
PStackFree(stack);
return res;
}
void PTreeObjMerge(PObjTree_p *root, PObjTree_p add, ComparisonFunctionType
cmpfun)
{
PStack_p stack = PStackAlloc();
PObjTree_p res;
PStackPushP(stack, add);
while(!PStackEmpty(stack))
{
add = PStackPopP(stack);
if(add)
{
PStackPushP(stack, add->lson);
PStackPushP(stack, add->rson);
res = PTreeObjInsert(root, add, cmpfun);
(void)res; assert(!res); /* Pointers should never be in two trees at
once for my intended application */
}
}
PStackFree(stack);
}
Term_p ESTermTop(Term_p term, int depth, VarBank_p freshvars)
{
PStack_p bindings = PStackAlloc();
Term_p handle, res;
assert(TermIsShared(term));
VarBankSetVCount(freshvars, FRESH_VAR_LIMIT);
term_set_prop_at_level(term, depth, TPOpFlag);
term_del_prop_level(term, depth-1, TPOpFlag);
res = term_top_marked(term, freshvars, bindings);
while(!PStackEmpty(bindings))
{
handle = PStackPopP(bindings);
assert(handle->binding);
handle->binding = NULL;
}
PStackFree(bindings);
return res;
}
long PTreeToPStack(PStack_p target_stack, PTree_p root)
{
long res = 0;
PStack_p stack = PStackAlloc();
PTree_p handle;
PStackPushP(stack, root);
while(!PStackEmpty(stack))
{
handle = PStackPopP(stack);
if(handle)
{
PStackPushP(target_stack, handle->key);
res++;
PStackPushP(stack,handle->lson);
PStackPushP(stack,handle->rson);
}
}
PStackFree(stack);
return res;
}
