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_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 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);
}
void graph_DeleteEdge(GRAPHNODE From, GRAPHNODE To)
/**************************************************************
INPUT: Two graph nodes.
RETURNS: Nothing.
EFFECT: Removes ALL edges (From, To) from a graph.
***************************************************************/
{
From->neighbors = list_PointerDeleteElement(From->neighbors, To);
}
LIST list_NPointerDifference(LIST List1, LIST List2)
/**************************************************************
INPUT: Two lists.
RETURNS: The list List1-List2.
CAUTION: Destructive on List1.
***************************************************************/
{
LIST Scan;
if (!list_Empty(List1)) {
for (Scan=List2; !list_Empty(Scan); Scan=list_Cdr(Scan))
List1 = list_PointerDeleteElement(List1, list_Car(Scan));
}
return List1;
}
LIST list_PointerDeleteDuplicates(LIST List)
/**************************************************************
INPUT: A list
RETURNS: The list where multiple occurrences are deleted.
CAUTION: Destructive.
EFFECT: The function needs
***************************************************************/
{
LIST Scan;
Scan = List;
while (!list_Empty(Scan)) {
list_Rplacd(Scan, list_PointerDeleteElement(list_Cdr(Scan),
list_Car(Scan)));
Scan = list_Cdr(Scan);
}
return List;
}
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;
}
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 SYMBOL symbol_SignatureCreate(char* String, int Type, int Arity,
int Status, PRECEDENCE Precedence)
/**************************************************************
INPUT: A pointer to a string, a type, the arity and the status
RETURNS: The symbol containing the passed parameters.
SUMMARY: Establishes a new symbol in the symbol table and returns the
internal representation (pointer and type).
CAUTION: The string is not copied!
***************************************************************/
{
SIGNATURE Entry;
#ifdef CHECK
if (!symbol_SignatureExists()) {
misc_StartErrorReport();
misc_ErrorReport("\n In symbol_SignatureCreate:");
misc_ErrorReport(" Module was initialized with no signature.\n");
misc_FinishErrorReport();
}
if (Type < 0 || Type >= symbol_SIGTYPES) {
misc_StartErrorReport();
misc_ErrorReport("\n In symbol_SignatureCreate: Illegal input.\n");
misc_FinishErrorReport();
}
#endif
if ((int)symbol_ACTINDEX >= symbol__MAXSIGNATURE &&
list_Empty(symbol_FREEDSYMBOLS)) {
misc_StartUserErrorReport();
misc_UserErrorReport("\n In symbol_SignatureCreate: No more symbols available.\n");
misc_FinishUserErrorReport();
}
if (strlen(String)>=symbol__SYMBOLMAXLEN) {
misc_StartUserErrorReport();
misc_UserErrorReport("\n In symbol_SignatureCreate: String too long.\n");
misc_FinishUserErrorReport();
}
Entry = symbol_GetSignature();
Entry->weight = 1;
Entry->props = 0;
Entry->name = String;
Entry->length = strlen(String);
Entry->arity = Arity;
Entry->generatedBy = list_Nil();
if (list_Empty(symbol_FREEDSYMBOLS)) {
Entry->info = symbol_SignatureSymbol(symbol_ACTINDEX, Type, Status);
symbol_SetSignature(symbol_ACTINDEX++, Entry);
}
else {
int Index;
Index = (int)list_Car(symbol_FREEDSYMBOLS);
symbol_FREEDSYMBOLS = list_PointerDeleteElement(symbol_FREEDSYMBOLS,
(POINTER)Index);
Entry->info = symbol_SignatureSymbol(Index, Type, Status);
symbol_SetSignature(Index, Entry);
}
/* Define precedence of symbol */
symbol_SetIncreasedOrdering(Precedence, Entry->info);
return Entry->info;
}
