void ACTermPrint(FILE* out, ACTerm_p term, Sig_p sig)
{
if(term->f_code < 0)
{
VarPrint(out, term->f_code);
}
else
{
int i;
ACTerm_p arg;
assert(term->args);
fputs(SigFindName(sig, term->f_code),out);
arg = PDArrayElementP(term->args, 0);
if(arg)
{
putc('(', out);
ACTermPrint(out, arg, sig);
for(i=1; (arg = PDArrayElementP(term->args, i)); i++)
{
putc(',', out);
ACTermPrint(out, arg, sig);
}
putc(')', out);
}
}
}
static void findex_remove_instance(FIndex_p index, FunCode i, void* inst)
{
void *tmp;
tmp = &(PDArrayElementP(index->index, i));
PTreeDeleteEntry(tmp, inst);
}
static PStack_p pdt_node_succ_stack_create(PDTNode_p node)
{
PStack_p result = PStackAlloc();
FunCode i = 0; /* Stiffle warning */
long tmpmaxvar = 0;
PDTNode_p next;
IntMapIter_p iter;
iter = IntMapIterAlloc(node->f_alternatives, 0, LONG_MAX);
while((next=IntMapIterNext(iter, &i)))
{
assert(next);
PStackPushP(result, next);
}
IntMapIterFree(iter);
for(i=1; i<=node->max_var; i++)
{
next = PDArrayElementP(node->v_alternatives, i);
if(next)
{
PStackPushP(result, next);
tmpmaxvar = i;
}
}
node->max_var = tmpmaxvar;
return result;
}
static void findex_add_instance(FIndex_p index, FunCode i, void* inst)
{
void *tmp;
tmp = &(PDArrayElementP(index->index, i));
PTreeStore(tmp, inst);
}
void PDTNodeFree(PDTNode_p tree)
{
FunCode i;
IntMapIter_p iter;
ClausePos_p tmp;
PDTNode_p subtree;
iter = IntMapIterAlloc(tree->f_alternatives, 0, LONG_MAX);
while((subtree = IntMapIterNext(iter, &i)))
{
assert(subtree);
}
IntMapIterFree(iter);
for(i=1; i<=tree->max_var; i++)
{
subtree = PDArrayElementP(tree->v_alternatives, i);
if(subtree)
{
PDTNodeFree(subtree);
}
}
while(tree->entries)
{
tmp = PTreeExtractRootKey(&tree->entries);
ClausePosCellFree(tmp);
}
pdtree_default_cell_free(tree);
}
void VarBankFree(VarBank_p junk)
{
int i;
assert(junk);
StrTreeFree(junk->ext_index);
for(i=0; i<junk->f_code_index->size; i++)
{
if(PDArrayElementP(junk->f_code_index, i))
{
TermTopFree(PDArrayElementP(junk->f_code_index, i));
}
}
PDArrayFree(junk->f_code_index);
VarBankCellFree(junk);
}
void pdt_node_print(FILE* out, PDTNode_p node, unsigned level)
{
if(node->entries)
{
PStack_p trav_stack;
PTree_p trav;
ClausePos_p entry;
fprintf(out, "%sleaf size=%ld age=%lu\n", IndentStr(2*level),
node->size_constr, node->age_constr);
trav_stack = PTreeTraverseInit(node->entries);
while((trav = PTreeTraverseNext(trav_stack)))
{
fprintf(out, "%s: ",IndentStr(2*level));
entry = trav->key;
ClausePrint(out, entry->clause, true);
fprintf(out, "\n");
}
PTreeTraverseExit(trav_stack);
}
else
{
FunCode i = 0; /* Stiffle warning */
PDTNode_p next;
IntMapIter_p iter;
fprintf(out, "%sinternal size=%ld age=%lu f_alts=%p, type=%d\n",
IndentStr(2*level),
node->size_constr,
node->age_constr,
node->f_alternatives,
node->f_alternatives?node->f_alternatives->type:-1);
iter = IntMapIterAlloc(node->f_alternatives, 0, LONG_MAX);
while((next=IntMapIterNext(iter, &i)))
{
fprintf(out, "%sBranch %ld\n", IndentStr(2*level), i);
pdt_node_print(out, next, level+1);
}
IntMapIterFree(iter);
for(i=1; i<=node->max_var; i++)
{
next = PDArrayElementP(node->v_alternatives, i);
if(next)
{
fprintf(out, "%sBranch %ld\n", IndentStr(2*level), -i);
pdt_node_print(out, next, level+1);
}
}
}
}
void FIndexFree(FIndex_p junk)
{
long i;
PTree_p tmp;
for(i = 0; i<junk->index->size; i++)
{
tmp = PDArrayElementP(junk->index, i);
PTreeFree(tmp);
}
PDArrayFree(junk->index);
FIndexCellFree(junk);
}
int ACTermCompare(ACTerm_p t1, ACTerm_p t2)
{
int res=0;
assert(t1 && t2);
res = t1->f_code -t2->f_code;
if((!res)&&t1->f_code > 0)
{
int i;
ACTerm_p arg1,arg2;
assert(t1->args&&t2->args);
for(i=0; !res; i++)
{
arg1 = PDArrayElementP(t1->args, i);
arg2 = PDArrayElementP(t2->args, i);
if(!arg1 && !arg2)
{
break;
}
else if(!arg1)
{
res = -1;
break;
}
else if(!arg2)
{
res = 1;
break;
}
res = ACTermCompare(arg1, arg2);
}
}
return res;
}
void VarBankVarsDelProp(VarBank_p bank, TermProperties prop)
{
Term_p handle;
int i;
for(i=0; i<bank->f_code_index->size; i++)
{
handle = PDArrayElementP(bank->f_code_index, i);
if(handle)
{
TermCellDelProp(handle, prop);
}
}
}
static void* pdt_select_alt_ref(PDTree_p tree, PDTNode_p node, Term_p term)
{
void* res;
if(TermIsVar(term))
{
tree->arr_storage_est -= PDArrayStorage(node->v_alternatives);
res = &(PDArrayElementP(node->v_alternatives,
-term->f_code));
tree->arr_storage_est += PDArrayStorage(node->v_alternatives);
}
else
{
tree->arr_storage_est -= IntMapStorage(node->f_alternatives);
res = IntMapGetRef(node->f_alternatives, term->f_code);
tree->arr_storage_est += IntMapStorage(node->f_alternatives);
}
return res;
}
void ACTermFree(ACTerm_p term)
{
assert(term);
if(term->f_code > 0)
{
int i;
ACTerm_p t;
for(i=0; (t=PDArrayElementP(term->args, i)); i++)
{
ACTermFree(t);
}
PDArrayFree(term->args);
}
else
{
assert(!term->args);
}
ACTermCellFree(term);
}
Eval_p cell;
OUTPRINT(1, "# Initializing proof state\n");
assert(ClauseSetEmpty(state->processed_pos_rules));
assert(ClauseSetEmpty(state->processed_pos_eqns));
assert(ClauseSetEmpty(state->processed_neg_units));
assert(ClauseSetEmpty(state->processed_non_units));
tmphcb = GetHeuristic("Uniq", state, control, &(control->heuristic_parms));
assert(tmphcb);
ClauseSetReweight(tmphcb, state->axioms);
traverse =
EvalTreeTraverseInit(PDArrayElementP(state->axioms->eval_indices,0),0);
while((cell = EvalTreeTraverseNext(traverse, 0)))
{
handle = cell->object;
new = ClauseCopy(handle, state->terms);
ClauseSetProp(new, CPInitial);
HCBClauseEvaluate(control->hcb, new);
DocClauseQuoteDefault(6, new, "eval");
ClausePushDerivation(new, DCCnfQuote, handle, NULL);
if(control->heuristic_parms.prefer_initial_clauses)
{
EvalListChangePriority(new->evaluations, -PrioLargestReasonable);
}
ClauseSetInsert(state->unprocessed, new);
}
static void pdtree_forward(PDTree_p tree, Subst_p subst)
{
PDTNode_p handle = tree->tree_pos, next = NULL;
FunCode i = tree->tree_pos->trav_count, limit;
Term_p term = PStackTopP(tree->term_stack);
limit = PDT_NODE_CLOSED(tree,handle);
while(i<limit)
{
if(((i==0)||(i>handle->max_var))&&!TermIsVar(term))
{
next = IntMapGetVal(handle->f_alternatives,term->f_code);
i++;
if(next)
{
PStackPushP(tree->term_proc, term);
TermLRTraverseNext(tree->term_stack);
next->trav_count = PDT_NODE_INIT_VAL(tree);
next->bound = false;
assert(!next->variable);
tree->tree_pos = next;
#ifdef MEASURE_EXPENSIVE
tree->visited_count++;
#endif
break;
}
}
else
{
next = PDArrayElementP(handle->v_alternatives,i);
i++;
if(next)
{
assert(next->variable);
if((!next->variable->binding)&&(!TermCellQueryProp(term,TPPredPos)))
{
PStackDiscardTop(tree->term_stack);
SubstAddBinding(subst, next->variable, term);
next->trav_count = PDT_NODE_INIT_VAL(tree);
next->bound = true;
tree->tree_pos = next;
tree->term_weight -= (TermStandardWeight(term) -
TermStandardWeight(next->variable));
#ifdef MEASURE_EXPENSIVE
tree->visited_count++;
#endif
break;
}
else if(TBTermEqual(next->variable->binding,term))
{
PStackDiscardTop(tree->term_stack);
next->trav_count = PDT_NODE_INIT_VAL(tree);
next->bound = false;
tree->tree_pos = next;
tree->term_weight -= (TermStandardWeight(term) -
TermStandardWeight(next->variable));
#ifdef MEASURE_EXPENSIVE
tree->visited_count++;
#endif
break;
}
}
}
}
handle->trav_count = i;
}
Term_p VarBankFCodeFind(VarBank_p bank, FunCode f_code)
{
assert(f_code<0);
return PDArrayElementP(bank->f_code_index, -f_code);
}
