void st_Print(st_INDEX StIndex, void (*Print)(POINTER))
/**************************************************************
INPUT: The root of an St.
SUMMARY: Prints a whole St.
***************************************************************/
{
LIST Scan;
if (st_Empty(StIndex)) {
puts("\n\nIndex empty.");
return;
}
fputs("\n\nroot: ", stdout);
printf(" Max: %d, Min: %d, ", st_Max(StIndex), st_Min(StIndex));
subst_Print(StIndex->subst);
putchar('\n');
if (st_IsLeaf(StIndex)) {
fputs(" =>", stdout);
if (Print)
for (Scan = StIndex->entries; Scan != NULL; Scan = list_Cdr(Scan)) {
putchar(' ');
Print(list_Car(Scan));
}
else
printf(" %d Entries", list_Length(StIndex->entries));
} else
for (Scan = StIndex->subnodes; Scan != NULL; Scan = list_Cdr(Scan))
st_PrintHelp(list_Car(Scan),2, Print);
puts("\n");
}
NAT list_Bytes(LIST List)
/**************************************************************
INPUT: A List.
RETURNS: The number of Bytes occupied by the list structure of <List>
EFFECT: the function needs time O(n), where <n> is the length
of the list.
***************************************************************/
{
return (list_Length(List)*sizeof(LIST_NODE));
}
static void st_PrintHelp(st_INDEX St, int Position, void (*Print)(POINTER))
/**************************************************************
INPUT: A node of an St, an indention and a print
function for the entries.
SUMMARY: Prints an St starting at node St.
***************************************************************/
{
int i;
if (St == (st_INDEX)NULL)
return;
for (i = 0; i < Position; i++)
putchar(' ');
puts("|");
for (i = 0; i < Position; i++)
putchar(' ');
fputs("+-", stdout);
printf(" Max: %d, Min: %d, ", st_Max(St), st_Min(St));
subst_Print(St->subst);
putchar('\n');
if (st_IsLeaf(St)) {
LIST Scan;
for (i = 0; i < Position; i++)
putchar(' ');
fputs(" =>", stdout);
if (Print)
for (Scan = St->entries; Scan != NULL; Scan = list_Cdr(Scan)) {
putchar(' ');
Print(list_Car(Scan));
}
else
printf(" %d Entries", list_Length(St->entries));
putchar('\n');
} else {
LIST Scan;
for (Scan = St->subnodes; Scan != NULL; Scan = list_Cdr(Scan))
st_PrintHelp(list_Car(Scan), Position + 2, Print);
}
}
LIST list_Sort(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 log n) *t), where <n>
is the length of the list and <t> is the time for
the test function.
CAUTION: Destructive.
***************************************************************/
{
LIST Result;
#ifdef CHECK
NAT originallength;
originallength = list_Length(List);
#endif
Result = list_MergeSort(List, Test);
#ifdef CHECK
if (!list_SortedInOrder(Result, Test)) {
misc_StartErrorReport();
misc_ErrorReport("\n In list_Sort: list_MergeSort did not sort properly.");
misc_FinishErrorReport();
}
if (list_Length(Result) != originallength) {
misc_StartErrorReport();
misc_ErrorReport("\n In list_Sort: list_MergeSort lost elements. ");
misc_FinishErrorReport();
}
#endif
return Result;
}
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));
}
LITPTR litptr_Create(LIST Indexlist, LIST Termsymblist)
/**********************************************************
INPUT: A list of indexes and a list of terms, i.e. a list of integers.
RETURNS: A LITPTR structure is created.
MEMORY: The integers in the created structure are the integers
in indexList, no copies.
***********************************************************/
{
LITPTR lit_ptr;
LIST Scan,varlist;
CLITERAL literal;
int literal_index,n,k;
n = list_Length(Indexlist);
lit_ptr = (LITPTR)memory_Malloc(sizeof(LITPTR_NODE));
litptr_SetLength(lit_ptr, n);
if (n > 0) {
lit_ptr->litptr = (CLITERAL *)memory_Malloc(n * sizeof(CLITERAL));
k = 0;
for (Scan = Indexlist; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
literal_index = (int)list_Car(Scan);
varlist = (LIST)list_Car(Termsymblist);
Termsymblist = list_Cdr(Termsymblist);
literal = literal_Create(FALSE,literal_index,varlist);
litptr_SetLiteral(lit_ptr, k, literal);
k++;
}
} else
lit_ptr->litptr = NULL;
return lit_ptr;
}
LIST dp_PrintProof(PROOFSEARCH Search, LIST Clauses, const char *FilePrefix)
/*********************************************************
INPUT: A proofsearch object, a list of empty clauses and
the prefix of the output file name.
RETURNS: The list of clauses required for the proof.
MEMORY: The returned list must be freed.
EFFECT: The proof is printed both to standard output and
to the file <FilePrefix>.prf.
**********************************************************/
{
LIST ProofClauses,Scan,EmptyClauses,AllClauses, ReducedProof;
LIST Missing, Incomplete, SplitClauses;
FLAGSTORE Flags;
Flags = prfs_Store(Search);
Missing = pcheck_ConvertParentsInSPASSProof(Search, Clauses);
if (!list_Empty(Missing)) {
puts("\nNOTE: clauses with following numbers have not been found:");
for (; !list_Empty(Missing); Missing = list_Pop(Missing))
printf("%d ", (int)list_Car(Missing));
putchar('\n');
}
EmptyClauses = list_Copy(Clauses);
ProofClauses = list_Nil();
AllClauses = list_Nconc(list_Copy(prfs_DocProofClauses(Search)),
list_Nconc(list_Copy(prfs_UsableClauses(Search)),
list_Copy(prfs_WorkedOffClauses(Search))));
/*
* collect proof clauses by noodling upward in the
* proof tree, starting from <EmptyClauses>.
* Before, add all splitting clauses to avoid gaps in split tree
*/
SplitClauses = list_Nil();
for (Scan = AllClauses; !list_Empty(Scan); Scan = list_Cdr(Scan))
if (clause_IsFromSplitting(list_Car(Scan)))
SplitClauses = list_Cons(list_Car(Scan), SplitClauses);
/* mark all needed clauses */
pcheck_ClauseListRemoveFlag(EmptyClauses, MARKED);
pcheck_ClauseListRemoveFlag(AllClauses, MARKED);
pcheck_MarkRecursive(EmptyClauses);
pcheck_MarkRecursive(SplitClauses);
/* collect all marked clauses */
ProofClauses = list_Nil();
for (Scan = AllClauses; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_GetFlag(list_Car(Scan), MARKED))
ProofClauses = list_Cons(list_Car(Scan), ProofClauses);
}
/* build reduced proof */
ProofClauses = list_Nconc(ProofClauses, list_Copy(EmptyClauses));
ProofClauses = pcheck_ClauseNumberMergeSort(ProofClauses);
ReducedProof = pcheck_ReduceSPASSProof(ProofClauses);
dp_SetProofDepth(pcheck_SeqProofDepth(ReducedProof));
pcheck_ParentPointersToParentNumbers(AllClauses);
pcheck_ParentPointersToParentNumbers(Clauses);
/* check reduced proof for clauses whose parents have been marked as
incomplete (HIDDEN flag) by ConvertParentsInSPASSProof */
Incomplete = list_Nil();
for (Scan = ReducedProof; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_GetFlag(list_Car(Scan), HIDDEN))
Incomplete = list_Cons(list_Car(Scan), Incomplete);
}
if (!list_Empty(Incomplete)) {
puts("NOTE: Following clauses in reduced proof have incomplete parent sets:");
for (Scan = Incomplete; !list_Empty(Scan); Scan = list_Cdr(Scan))
printf("%d ", clause_Number(list_Car(Scan)));
putchar('\n');
}
printf("\n\nHere is a proof with depth %d, length %d :\n",
dp_ProofDepth(), list_Length(ReducedProof));
clause_ListPrint(ReducedProof);
if (flag_GetFlagValue(Flags, flag_FPDFGPROOF))
dp_FPrintDFGProof(ReducedProof, FilePrefix, Flags, prfs_Precedence(Search));
fflush(stdout);
list_Delete(EmptyClauses);
list_Delete(AllClauses);
list_Delete(ProofClauses);
list_Delete(SplitClauses);
list_Delete(Incomplete);
return ReducedProof;
}
static __inline__ TERM ia_TermCreate(char* Name, LIST Arguments)
/* Look up the symbol, check its arity and create the term */
{
return term_Create(ia_Symbol(Name,list_Length(Arguments)), Arguments);
}
LIST list_MergeSort (LIST L, BOOL (*Test) (POINTER, POINTER))
/**************************************************************
INPUT: A list, and an ordering function.
RETURNS: The list sorted with respect to the ordering function.
EFFECT: The function needs time O((n log n) * t), where
<n> is the length of the input list and <t> is the
execution time of the ordering function.
***************************************************************/
{
LIST Result;
#ifdef CHECK
NAT originallength;
originallength = list_Length(L);
#endif
/* Only sort if list has more than one element */
if (!list_Empty(L) && !list_Empty(list_Cdr(L))) {
LIST lowerhalf;
LIST greaterhalf;
LIST *lowerhalfptr;
LIST *greaterhalfptr;
lowerhalfptr = &lowerhalf;
greaterhalfptr = &greaterhalf;
list_Split(L, lowerhalfptr, greaterhalfptr);
#ifdef CHECK
if((list_Length(lowerhalf) + list_Length(greaterhalf))
!= originallength) {
/* output an error message and exit */
misc_StartErrorReport();
misc_ErrorReport("\n In list_MergeSort: Split lists' total sizes");
misc_ErrorReport("\n don't match original list's size.");
misc_FinishErrorReport();
}
#endif
lowerhalf = list_MergeSort(lowerhalf, Test);
greaterhalf = list_MergeSort(greaterhalf, Test);
#ifdef CHECK
if((list_Length(lowerhalf) + list_Length(greaterhalf))
!= originallength) {
/* output an error message and exit */
misc_StartErrorReport();
misc_ErrorReport("\n In list_MergeSort: Mergesorted lists' total sizes");
misc_ErrorReport("\n don't match original list's size.");
misc_FinishErrorReport();
}
#endif
Result = list_Merge(lowerhalf, greaterhalf, Test);
#ifdef CHECK
if(list_Length(Result) != originallength) {
/* output an error message and exit */
misc_StartErrorReport();
misc_ErrorReport("\n In list_MergeSort: Merged list's size doesn't match ");
misc_ErrorReport("\n original list's size.");
misc_FinishErrorReport();
}
#endif
}
else {
Result = L;
}
return Result;
}
