LIST symbol_SortByPrecedence(LIST Symbols, PRECEDENCE Precedence) /************************************************************** INPUT: A list of symbols, and a precedence. RETURNS: The same list where the elements are sorted with respect to decreasing precedence. CAUTION: Destructive. ***************************************************************/ { LIST Scan1,Scan2,Min; POINTER Exchange; /* We can't use list_Sort, since list_Sort expects an ordering function that receives two arguments. Since symbol_PrecedenceGreater requires three arguments, we have to define our own sorting function. */ for (Scan1=Symbols; !list_Empty(Scan1); Scan1=list_Cdr(Scan1)) { Min = Scan1; for (Scan2 = list_Cdr(Scan1); !list_Empty(Scan2); Scan2 = list_Cdr(Scan2)) if (symbol_PrecedenceGreater(Precedence, (SYMBOL) list_Car(Scan2), (SYMBOL) list_Car(Min))) { Exchange = list_Car(Min); list_Rplaca(Min, list_Car(Scan2)); list_Rplaca(Scan2, Exchange); } } return Symbols; }
LIST list_InsertionSort(LIST List, BOOL (*Test)(POINTER, POINTER)) /************************************************************** INPUT: A list and a 'less' function on the elements. RETURNS: The same list where the elements are sorted with respect to Test. EFFECT: The function needs time O(n^2*t), where <n> is the length of the list and <t> is the time for the test function. CAUTION: Destructive. ***************************************************************/ { LIST Scan1,Scan2,Min; POINTER Exchange; for (Scan1=List; !list_Empty(Scan1); Scan1=list_Cdr(Scan1)) { Min = Scan1; for (Scan2 = list_Cdr(Scan1); !list_Empty(Scan2); Scan2 = list_Cdr(Scan2)) if (Test(list_Car(Scan2), list_Car(Min))) { Exchange = list_Car(Min); list_Rplaca(Min, list_Car(Scan2)); list_Rplaca(Scan2, Exchange); } } return List; }
static LIST rpos_ContMultisetDifference(CONTEXT C1, TERM T1, CONTEXT C2, TERM T2) /************************************************************** INPUT: Two contexts and two terms. RETURNS: The multiset difference between the arguments of both terms with respect to rpos_ContEqual. EFFECT: Variable bindings are considered. ***************************************************************/ { LIST result, scan1, scan2; /* Don't apply bindings at top level, since that happened */ /* in rpos_ContGreaterEqual */ /* We can't use list_NMultisetDifference, since that function */ /* expects an equality functions for terms that takes two terms */ /* as arguments. We also need the two contexts resolve variable */ /* bindings. */ result = list_Copy(term_ArgumentList(T1)); for (scan2 = term_ArgumentList(T2); !list_Empty(scan2); scan2 = list_Cdr(scan2)) { /* Delete at most one occurrence of the */ /* current element of list2 from list1 */ for (scan1 = result; !list_Empty(scan1); scan1 = list_Cdr(scan1)) { if (list_Car(scan1) != NULL && rpos_ContEqual(C1, list_Car(scan1), C2, list_Car(scan2))) { /* arg of list1 wasn't deleted earlier and terms are equal */ list_Rplaca(scan1, NULL); /* Mark argument of T1 as deleted */ break; } } } return list_PointerDeleteElement(result, NULL); /* Delete all marked terms */ }
static void split_DeleteInvalidClausesFromStack(PROOFSEARCH Search) /************************************************************** INPUT: A proof search object. EFFECT: All clauses in the split stack of <Search> that have a higher split level than the current <Search> split level are deleted. ***************************************************************/ { LIST Scan1,Scan2,ClauseList; int Level; CLAUSE Clause; Level = prfs_ValidLevel(Search); for (Scan1=prfs_SplitStack(Search);!list_Empty(Scan1);Scan1=list_Cdr(Scan1)) { ClauseList = prfs_SplitDeletedClauses(list_Car(Scan1)); for (Scan2 = ClauseList; !list_Empty(Scan2); Scan2 = list_Cdr(Scan2)) { Clause = (CLAUSE)list_Car(Scan2); if (!prfs_IsClauseValid(Clause,Level)) { prfs_InsertDocProofClause(Search,Clause); list_Rplaca(Scan2, NULL); } } prfs_SplitSetDeletedClauses(list_Car(Scan1),list_PointerDeleteElement(ClauseList, NULL)); } }
static LIST split_DeleteInvalidClausesFromList(PROOFSEARCH Search, int Level, LIST ClauseList) /************************************************************** INPUT: A proof search object, a split level and a list of clauses. RETURNS: The list where invalid clauses wrt 'Level' are deleted. EFFECT: The invalid clauses are stored in the doc proof index of the proof search object if necessary. ***************************************************************/ { LIST Scan; CLAUSE Clause; /*printf("\nDiese Liste soll von ungueltigen (Level > %d) " "befreit werden: \n",Level);fflush(stdout); clause_ListPrint(ClauseList);*/ for (Scan = ClauseList; !list_Empty(Scan); Scan = list_Cdr(Scan)) { Clause = list_Car(Scan); if (!prfs_IsClauseValid(Clause,Level)) { prfs_InsertDocProofClause(Search,Clause); list_Rplaca(Scan, NULL); } } return list_PointerDeleteElement(ClauseList, NULL); }
static LIST split_DeleteClausesDependingOnLevelFromList(PROOFSEARCH Search, LIST ClauseList, int Level, LIST* New) /************************************************************** INPUT: A proof search object, a list of unshared clauses and a split level. EFFECT: Deletes all clauses depending on split level from <ClauseList>. All split stored deleted clauses from the level of the deleted clauses from <ClauseList> are stored in <*New>. RETURNS: The updated list and the recover clauses in <*New>. ***************************************************************/ { LIST Scan; CLAUSE Clause; SPLIT Reinsert; for (Scan = ClauseList; !list_Empty(Scan); Scan = list_Cdr(Scan)) { Clause = list_Car(Scan); if (clause_DependsOnSplitLevel(Clause, Level)) { Reinsert = prfs_GetSplitOfLevel(clause_SplitLevel(Clause), Search); if (prfs_SplitDeletedClauses(Reinsert) != list_Nil()) { *New = list_Nconc(prfs_SplitDeletedClauses(Reinsert), *New); prfs_SplitSetDeletedClauses(Reinsert, list_Nil()); } prfs_InsertDocProofClause(Search,Clause); list_Rplaca(Scan, NULL); } } return list_PointerDeleteElement(ClauseList, NULL); }
static TERM cont_CopyAndApplyIndexVariableBindings(const CONTEXT Context, TERM Term) { SYMBOL TermTop; #ifdef CHECK if (symbol_IsIndexVariable(term_TopSymbol(Term)) && !cont_VarIsBound(Context, term_TopSymbol(Term))) { misc_StartErrorReport(); misc_ErrorReport("\n In cont_CopyAndApplyIndexVariableBindings:"); misc_ErrorReport(" Expected bound index variable."); misc_FinishErrorReport(); } #endif TermTop = term_TopSymbol(Term); while (symbol_IsIndexVariable(TermTop)) { if (cont_VarIsBound(Context, TermTop)) { Term = cont_ContextBindingTerm(Context, TermTop); TermTop = term_TopSymbol(Term); } } if (term_IsComplex(Term)) { LIST Scan, ArgumentList; for (Scan = ArgumentList = list_Copy(term_ArgumentList(Term)); !list_Empty(Scan); Scan = list_Cdr(Scan)) list_Rplaca(Scan, cont_CopyAndApplyIndexVariableBindings(Context, list_Car(Scan))); return term_Create(TermTop, ArgumentList); } else return term_Create(TermTop, list_Nil()); }
TERM cont_CopyAndApplyBindings(CONTEXT TermContext, TERM Term) { while (term_IsVariable(Term)) { SYMBOL TermTop; TermTop = term_TopSymbol(Term); if (cont_VarIsBound(TermContext, TermTop)) { CONTEXT HelpContext; HelpContext = cont_ContextBindingContext(TermContext, TermTop); Term = cont_ContextBindingTerm(TermContext, TermTop); TermContext = HelpContext; } else break; } if (term_IsComplex(Term)) { LIST Scan, ArgumentList; for (Scan = ArgumentList = list_Copy(term_ArgumentList(Term)); !list_Empty(Scan); Scan = list_Cdr(Scan)) list_Rplaca(Scan, cont_CopyAndApplyBindings(TermContext, list_Car(Scan))); return term_Create(term_TopSymbol(Term), ArgumentList); } else return term_Create(term_TopSymbol(Term), list_Nil()); }
LIST list_NReverse(LIST List) /************************************************************** INPUT: A list RETURNS: The same list with reversed order of items. CAUTION: Destructive. The function needs time O(n), where <n> is the length of the list. ***************************************************************/ { LIST ReverseList; LIST Scan1; LIST Scan2; ReverseList = list_Nil(); for (Scan1=List; !list_Empty(Scan1); Scan1=list_Cdr(Scan1)) ReverseList = list_Cons(list_Car(Scan1),ReverseList); for (Scan1=List, Scan2=ReverseList; !list_Empty(Scan1); Scan1=list_Cdr(Scan1), Scan2=list_Cdr(Scan2)) list_Rplaca(Scan1, list_Car(Scan2)); list_Delete(ReverseList); return List; }
TERM cont_CopyAndApplyBindingsCom(const CONTEXT Context, TERM Term) { while (term_IsVariable(Term) && cont_VarIsBound(Context, term_TopSymbol(Term))) Term = cont_ContextBindingTerm(Context, term_TopSymbol(Term)); if (term_IsComplex(Term)) { LIST Scan, ArgumentList; for (Scan = ArgumentList = list_Copy(term_ArgumentList(Term)); !list_Empty(Scan); Scan = list_Cdr(Scan)) list_Rplaca(Scan, cont_CopyAndApplyBindingsCom(Context, list_Car(Scan))); return term_Create(term_TopSymbol(Term), ArgumentList); } else return term_Create(term_TopSymbol(Term), list_Nil()); }
BOOL list_PointerReplaceMember(LIST List, POINTER Old, POINTER New) /************************************************************** INPUT: A list, a pointer to an old element, a pointer to a new element RETURNS: TRUE iff <Old> was replaced. EFFECT: The first occurrence of <Old> in the list is replaced by <New>. ***************************************************************/ { while (!list_Empty(List)) { if (Old == list_Car(List)) { list_Rplaca(List, New); return TRUE; } List = list_Cdr(List); } return FALSE; }
void list_NMapCar(LIST List, POINTER (*ElementFunc)(POINTER)) /************************************************************** INPUT: A List and a function for the elements. RETURNS: The List where all elements are replaced by the result of the function calls of <ElementFunc> to the elements CAUTION: The List is not copied ! The function needs time O(n*f), where <n> is the length of the list and <f> is the time for a call of the element function. ***************************************************************/ { LIST Scan; for (Scan = List; !list_Empty(Scan); Scan = list_Cdr(Scan)) list_Rplaca(Scan, ElementFunc(list_Car(Scan))); }
LIST split_ExtractEmptyClauses(LIST Clauses, LIST* EmptyClauses) /************************************************************** INPUT: A list of clauses and a pointer to a list of empty clauses. RETURNS: <Clauses> without all empty clauses where the empty clauses are moved to <EmptyClauses> MEMORY: Destructive on <Clauses>. ***************************************************************/ { LIST Scan; CLAUSE Clause; for (Scan=Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) { Clause = (CLAUSE)list_Car(Scan); if (clause_IsEmptyClause(Clause)) { *EmptyClauses = list_Cons(Clause,*EmptyClauses); list_Rplaca(Scan,NULL); } } Clauses = list_PointerDeleteElement(Clauses,NULL); return Clauses; }
TERM cont_SymbolApplyBindings(CONTEXT TermContext, SYMBOL Symbol) /************************************************************** INPUT: A call-by-ref context and a variable symbol. RETURNS: The recursively dereferenced term and the corresponding context, NULL if the symbol is not bound SUMMARY: Dereferences bindings of variables. CAUTION: In general, the context of the returned term is different to the input context. ***************************************************************/ { TERM Term; Term = (TERM)NULL; while (symbol_IsVariable(Symbol)) { if (cont_VarIsBound(TermContext, Symbol)) { CONTEXT HelpContext; HelpContext = cont_ContextBindingContext(TermContext, Symbol); Term = cont_ContextBindingTerm(TermContext, Symbol); TermContext = HelpContext; Symbol = term_TopSymbol(Term); } else break; } if (Term != (TERM)NULL && term_IsComplex(Term)) { LIST Scan, ArgumentList; for (Scan = ArgumentList = list_Copy(term_ArgumentList(Term)); !list_Empty(Scan); Scan = list_Cdr(Scan)) list_Rplaca(Scan, cont_CopyAndApplyBindings(TermContext, list_Car(Scan))); return term_Create(term_TopSymbol(Term), ArgumentList); } return Term; }
BOOL st_EntryDelete(st_INDEX StIndex, POINTER Pointer, TERM Term, const CONTEXT Context) /************************************************************** INPUT: RETURNS: EFFECTS: ***************************************************************/ { BOOL Found; LIST Subnodes; SYMBOL FirstDomain; cont_Check(); FirstDomain = symbol_FirstIndexVariable(); cont_CreateBinding(Context, FirstDomain, Context, Term); for (Found = FALSE, Subnodes = StIndex->subnodes; list_Exist(Subnodes); Subnodes = list_Cdr(Subnodes)) { st_INDEX CurrentNode; CurrentNode = (st_INDEX)list_Car(Subnodes); cont_StartBinding(); if (subst_Variation(Context, CurrentNode->subst)) { list_Rplaca(Subnodes, st_EntryDeleteHelp(Context, CurrentNode, Pointer, &Found)); if (Found) { StIndex->subnodes = list_PointerDeleteElement(StIndex->subnodes, NULL); if (list_Exist(StIndex->subnodes)) { CurrentNode = (st_INDEX)list_Car(StIndex->subnodes); st_SetMax(StIndex, st_Max(CurrentNode)); st_SetMin(StIndex, st_Min(CurrentNode)); for (Subnodes = list_Cdr(StIndex->subnodes); list_Exist(Subnodes); Subnodes = list_Cdr(Subnodes)) { CurrentNode = (st_INDEX)list_Car(Subnodes); if (st_Max(CurrentNode) > st_Max(StIndex)) st_SetMax(StIndex, st_Max(CurrentNode)); if (st_Min(CurrentNode) < st_Min(StIndex)) st_SetMin(StIndex, st_Min(CurrentNode)); } } else { st_SetMax(StIndex, 0); st_SetMin(StIndex, 0); } break; } } cont_BackTrack(); } cont_Reset(); return Found; }
static st_INDEX st_EntryDeleteHelp(const CONTEXT Context, st_INDEX StIndex, POINTER Pointer, BOOL* Found) /************************************************************** INPUT: The root of an abstraction tree (StIndex), a pointer to a specific entry of the tree and a query term. RETURNS: Nothing. SUMMARY: Uses Term in order to find Pointer in the tree. EFFECTS: Will delete nodes of StIndex. ***************************************************************/ { if (st_IsLeaf(StIndex)) { *Found = list_DeleteFromList(&(StIndex->entries), Pointer); if (list_Exist(StIndex->entries)) return StIndex; else { subst_Delete(StIndex->subst); st_Free(StIndex); return NULL; } } else { LIST Subnodes; for (Subnodes = StIndex->subnodes; list_Exist(Subnodes); Subnodes = list_Cdr(Subnodes)) { st_INDEX CurrentNode; CurrentNode = (st_INDEX)list_Car(Subnodes); cont_StartBinding(); if (subst_Variation(Context, CurrentNode->subst)) { list_Rplaca(Subnodes, st_EntryDeleteHelp(Context, CurrentNode, Pointer, Found)); if (*Found) { if (list_DeleteFromList(&(StIndex->subnodes), NULL)) if (list_Empty(list_Cdr(StIndex->subnodes))) { /* 'StIndex' has one subnode only. */ st_NodeMergeWithSon(StIndex); return StIndex; } /* Assertion: 'StIndex' is an inner node. */ CurrentNode = (st_INDEX)list_Car(StIndex->subnodes); st_SetMax(StIndex, st_Max(CurrentNode)); st_SetMin(StIndex, st_Min(CurrentNode)); for (Subnodes = list_Cdr(StIndex->subnodes); list_Exist(Subnodes); Subnodes = list_Cdr(Subnodes)) { CurrentNode = (st_INDEX)list_Car(Subnodes); if (st_Max(CurrentNode) > st_Max(StIndex)) st_SetMax(StIndex, st_Max(CurrentNode)); if (st_Min(CurrentNode) < st_Min(StIndex)) st_SetMin(StIndex, st_Min(CurrentNode)); } return StIndex; } } cont_BackTrack(); } return StIndex; } }