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; }