CLAUSE red_Terminator(CLAUSE RedClause, NAT n, SHARED_INDEX WoIndex,
SHARED_INDEX UsIndex, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A clause, two shared indexes, a number <n>
restricting the number of non-unit clauses in
a possible terminator situation, a flag store
and a precedence.
RETURNS: An empty clause if a terminator with at most <n>
non-unit clauses is found, NULL otherwise.
EFFECT: See also description of red_SearchTerminator.
***************************************************************/
{
LIST Rest, IndexList;
CLAUSE Result;
if (clause_Length(RedClause) > 1) /* non-unit clause */
n--;
/* Pass the indexes as a list to sub-functions */
IndexList = list_Cons(WoIndex, list_List(UsIndex));
Rest = clause_GetLiteralList(RedClause);
Result = red_SearchTerminator(n, Rest, list_Nil(), subst_Nil(),
clause_MaxVar(RedClause), IndexList, Flags,
Precedence);
/* cleanup */
list_Delete(IndexList);
list_Delete(Rest);
return Result;
}
st_INDEX st_IndexCreate(void)
/**************************************************************
INPUT: None.
RETURNS: A pointer to a new St-Index.
SUMMARY: Creates a new St-index.
***************************************************************/
{
st_INDEX StIndex;
StIndex = st_Get();
StIndex->subnodes = list_Nil();
StIndex->entries = list_Nil();
StIndex->subst = subst_Nil();
st_SetMax(StIndex, 0);
st_SetMin(StIndex, 0);
return StIndex;
}
void st_EntryCreate(st_INDEX StIndex, POINTER Pointer, TERM Term, const CONTEXT Context)
/**************************************************************
INPUT:
RETURNS:
EFFECTS:
***************************************************************/
{
st_INDEX Current;
st_INDEX BestNonVariant;
SYMBOL FirstDomain;
st_MINMAX MinMax;
cont_Check();
MinMax = term_ComputeSize(Term);
/* CREATE INITIAL BINDING AND INITIALIZE LOCAL VARIABLES */
FirstDomain = cont_NextIndexVariable(Context);
cont_CreateBinding(Context, FirstDomain, Context, Term);
Current = StIndex;
if (st_Max(Current) < MinMax)
st_SetMax(Current, MinMax);
else if (st_Min(Current) > MinMax)
st_SetMin(Current, MinMax);
/* FIND "LAST" VARIATION */
while (!st_IsLeaf(Current) &&
(Current = st_FirstVariant(Context, Current->subnodes, &BestNonVariant))) {
if (st_Max(Current) < MinMax)
st_SetMax(Current, MinMax);
else if (st_Min(Current) > MinMax)
st_SetMin(Current, MinMax);
StIndex = Current;
}
if (cont_BindingsSinceLastStart()==0 && Current && st_IsLeaf(Current)) {
/* INSERT ENTRY EQUAL MODULO RENAMING */
Current->entries = list_Cons(Pointer, Current->entries);
} else if (BestNonVariant) {
/* CREATE INNER NODE AND A NEW LEAF */
SUBST ComGen, SubstOld, SubstNew;
if (!st_IsLeaf(BestNonVariant))
st_CloseUsedVariables(Context, BestNonVariant->subnodes);
ComGen = subst_ComGen(Context, BestNonVariant->subst, &SubstOld, &SubstNew);
st_NodeAddInner(BestNonVariant,
SubstOld,
subst_CloseOpenVariables(SubstNew),
ComGen,
MinMax,
Pointer);
} else
/* ADD A SINGLE LEAF NODE TO FATHER */
StIndex->subnodes =
list_Cons(st_NodeAddLeaf(subst_CloseOpenVariables(subst_Nil()), MinMax,
Pointer),
StIndex->subnodes);
cont_Reset();
}
LIST inf_URResolution(CLAUSE Clause, SHARED_INDEX Index, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A clause, a shared index, a flag store and a precedence.
RETURNS: The list of UR resolution resolvents.
EFFECT: The flag store and the precedence are needed to create
the resolvents.
***************************************************************/
{
LIST Result;
if (clause_Length(Clause) != 1) {
/* Clause isn't unit clause */
Result = inf_NonUnitURResolution(Clause, -1, list_Nil(), subst_Nil(),
clause_MaxVar(Clause), Index, Flags,
Precedence);
}
else {
/* Clause is unit clause, so search partner literals in non-unit clauses */
LITERAL Lit, PLit;
TERM Atom;
LIST Partners, FoundMap;
SYMBOL MaxVar, PMaxVar;
SUBST LeftSubst, RightSubst;
CLAUSE PClause;
int PLitInd;
BOOL Swapped;
Result = list_Nil();
Lit = clause_GetLiteral(Clause, clause_FirstLitIndex());
Atom = term_Copy(clause_LiteralAtom(Lit));
Swapped = FALSE;
/* The following 'endless' loop runs twice for equality literals */
/* and only once for other literals. */
while (TRUE) {
/* Get complementary literals from non-unit clauses */
Partners = inf_GetURPartnerLits(Atom, Lit, FALSE, Index);
for ( ; !list_Empty(Partners); Partners = list_Pop(Partners)) {
PLit = list_Car(Partners);
PLitInd = clause_LiteralGetIndex(PLit);
PClause = clause_LiteralOwningClause(PLit); /* non-unit clause */
PMaxVar = clause_MaxVar(PClause);
term_StartMaxRenaming(PMaxVar);
term_Rename(Atom); /* Rename atom from unit clause */
MaxVar = term_MaxVar(Atom);
if (symbol_GreaterVariable(PMaxVar, MaxVar))
MaxVar = PMaxVar;
/* Get the substitution */
cont_Check();
unify_UnifyNoOC(cont_LeftContext(), clause_LiteralAtom(PLit),
cont_RightContext(), Atom);
subst_ExtractUnifier(cont_LeftContext(), &LeftSubst,
cont_RightContext(), &RightSubst);
cont_Reset();
/* We don't need the substitution for the unit clause */
subst_Delete(RightSubst);
FoundMap = list_List(list_PairCreate(PLit, Lit));
Result = list_Nconc(inf_NonUnitURResolution(PClause, PLitInd, FoundMap,
LeftSubst, MaxVar, Index,
Flags, Precedence),
Result);
list_DeletePairList(FoundMap);
subst_Delete(LeftSubst);
}
/* loop control */
if (!fol_IsEquality(Atom) || Swapped)
break;
else {
term_EqualitySwap(Atom);
Swapped = TRUE;
}
} /* end of endless loop */
term_Delete(Atom);
}
return Result;
}
