static BOOL tab_HasEmptyClause(TABLEAU T)
/**************************************************************
INPUT: A tableau
RETURNS: TRUE iff an empty clause is among the clauses
on this level
***************************************************************/
{
LIST Scan;
for (Scan = tab_Clauses(T); !list_Empty(Scan); Scan = list_Cdr(Scan))
if (clause_IsEmptyClause(list_Car(Scan)))
return TRUE;
return FALSE;
}
void tab_CheckEmpties(TABLEAU T)
/**************************************************************
INPUT: A tableau
RETURNS: Nothing.
EFFECTS: Prints warnings if non-leaf nodes contain
empty clauses (which should not be the case
after pruning any more), of if leaf nodes
contain more than one empty clause
***************************************************************/
{
LIST Scan, Empties;
BOOL Printem;
if (tab_IsEmpty(T))
return;
/* get all empty clauses in this node */
Empties = list_Nil();
for (Scan = tab_Clauses(T); !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_IsEmptyClause(list_Car(Scan)))
Empties = list_Cons(list_Car(Scan), Empties);
}
Printem = FALSE;
if (!list_Empty(Empties) && !tab_IsLeaf(T)) {
puts("\nNOTE: non-leaf node contains empty clauses.");
Printem = TRUE;
}
if (tab_IsLeaf(T) && list_Length(Empties) > 1) {
puts("\nNOTE: Leaf contains more than one empty clauses.");
Printem = TRUE;
}
if (Printem) {
puts("Clauses:");
clause_PParentsListPrint(tab_Clauses(T));
}
list_Delete(Empties);
tab_CheckEmpties(tab_LeftBranch(T));
tab_CheckEmpties(tab_RightBranch(T));
}
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;
}
void tab_GetEarliestEmptyClauses(TABLEAU T, LIST* L)
/**************************************************************
INPUT : A tableau, a list of clauses by reference
RETURNS: Nothing.
EFFECTS: For each leaf node, adds empty clauses in
leaf nodes to <L>. If the leaf node contains only one
empty clause, it is added to <L> anyway.
If the leaf node contains more than one empty clause,
the earliest derived empty clause is added to <L>.
***************************************************************/
{
CLAUSE FirstEmpty;
LIST Scan;
if (tab_IsEmpty(T))
return;
if (tab_IsLeaf(T)) {
FirstEmpty = clause_Null();
for (Scan = tab_Clauses(T); !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_IsEmptyClause(list_Car(Scan))) {
if (FirstEmpty == clause_Null())
FirstEmpty = list_Car(Scan);
else if (clause_Number(FirstEmpty) > clause_Number(list_Car(Scan)))
FirstEmpty = list_Car(Scan);
}
}
if (FirstEmpty != clause_Null())
(*L) = list_Cons(FirstEmpty, *L);
}
tab_GetEarliestEmptyClauses(tab_LeftBranch(T), L);
tab_GetEarliestEmptyClauses(tab_RightBranch(T), L);
}
