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