void flag_FPrint(FILE* File, FLAGSTORE Store)
/**************************************************************
INPUT: A File to print to, and a FlagStore.
RETURNS: Nothing.
EFFECT: Prints the values of all flags to File.
***************************************************************/
{
FLAG_ID i;
char name[30];
fputs("list_of_settings(SPASS).{*", File);
for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i+= (FLAG_ID) 3) {
sprintf(name,"set_flag(%s,%d).", flag_Name(i), flag_GetFlagValue(Store, i));
fprintf(File,"\n %-30s",name);
if (i+1 < flag_MAXFLAG) {
sprintf(name,"set_flag(%s,%d).", flag_Name(i+ (FLAG_ID) 1), flag_GetFlagValue(Store, i+ (FLAG_ID) 1));
fprintf(File," %-30s",name);
if (i+2 < flag_MAXFLAG) {
sprintf(name," set_flag(%s,%d).", flag_Name(i+ (FLAG_ID) 2), flag_GetFlagValue(Store, i+ (FLAG_ID) 2));
fprintf(File," %-30s",name);
}
}
}
fputs("*}\nend_of_list.\n", File);
}
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;
}
void ana_Print(FLAGSTORE Flags, PRECEDENCE Precedence)
/**************************************************************
INPUT: A flag store and a precedence.
RETURNS: Nothing.
EFFECT: The results of an analysis stored in the module variables
is printed to stdout.
***************************************************************/
{
const char* Horn;
if (ana_NONHORNCLAUSES == 0)
Horn = "Horn";
else
Horn = "Non-Horn";
if (ana_MONADIC && !ana_NONMONADIC) {
printf("\n This is a monadic %s problem",Horn);
if (ana_PEQUATIONS || ana_NEQUATIONS)
fputs(" with equality.", stdout);
else
fputs(" without equality.", stdout);
}
else
if (ana_PEQUATIONS || ana_NEQUATIONS) {
if (ana_NONMONADIC || ana_MONADIC || ana_PROP)
printf("\n This is a first-order %s problem containing equality.",Horn);
else
if (ana_NONUNIT)
printf("\n This is a pure equality %s problem.",Horn);
else
fputs("\n This is a unit equality problem.", stdout);
}
else
if (ana_NONMONADIC || ana_MONADIC)
printf("\n This is a first-order %s problem without equality.",Horn);
if (ana_PUREPROPOSITIONAL)
printf("\n This is a propositional %s problem.",Horn);
else
if (ana_FINDOMAIN || !ana_FUNCTIONS) {
fputs("\n This is a problem that has, if any, a finite domain model.",
stdout);
if (ana_FINDOMAIN)
fputs("\n There is a finite domain clause.", stdout);
if (!ana_FUNCTIONS)
fputs("\n There are no function symbols.", stdout);
}
if (ana_NONTRIVDOMAIN)
fputs("\n This is a problem that has, if any, a non-trivial domain model.",
stdout);
if (ana_SORTRES) {
fputs("\n This is a problem that contains sort information.", stdout);
if (ana_PEQUATIONS) {
if (ana_SORTMANYEQUATIONS)
fputs("\n All equations are many sorted.", stdout);
else {
if (ana_SORTDECEQUATIONS)
fputs("\n All equations are sort-decreasing.", stdout);
}
}
}
if (ana_CONCLAUSES > 0 && ana_CONGROUND && !ana_PUREPROPOSITIONAL)
fputs("\n The conjecture is ground.", stdout);
if (!list_Empty(ana_FINITEMONADICPREDICATES)) {
LIST Scan;
fputs("\n The following monadic predicates have finite extensions: ", stdout);
for (Scan=ana_FINITEMONADICPREDICATES;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
symbol_Print((SYMBOL)list_Car(Scan));
if (!list_Empty(list_Cdr(Scan)))
fputs(", ", stdout);
}
putchar('.');
}
printf("\n Axiom clauses: %d Conjecture clauses: %d",ana_AXIOMCLAUSES,ana_CONCLAUSES);
flag_PrintInferenceRules(Flags);
flag_PrintReductionRules(Flags);
fputs("\n Extras : ", stdout);
if (flag_GetFlagValue(Flags, flag_SATINPUT))
fputs("Input Saturation, ", stdout);
else
fputs("No Input Saturation, ", stdout);
if (flag_GetFlagValue(Flags, flag_SELECT) == flag_SELECTOFF)
fputs("No Selection, ", stdout);
else
if (flag_GetFlagValue(Flags, flag_SELECT) == flag_SELECTIFSEVERALMAXIMAL)
fputs("Dynamic Selection, ", stdout);
else
fputs("Always Selection, ", stdout);
if (flag_GetFlagValue(Flags, flag_SPLITS) == flag_SPLITSUNLIMITED)
fputs("Full Splitting, ", stdout);
else
if (flag_GetFlagValue(Flags, flag_SPLITS) == flag_SPLITSOFF)
fputs("No Splitting, ", stdout);
else
printf("Maximum of %d Splits, ",flag_GetFlagValue(Flags, flag_SPLITS));
if (flag_GetFlagValue(Flags, flag_FULLRED))
fputs("Full Reduction, ", stdout);
else
fputs("Lazy Reduction, ", stdout);
printf(" Ratio: %d, FuncWeight: %d, VarWeight: %d",
flag_GetFlagValue(Flags, flag_WDRATIO),
flag_GetFlagValue(Flags, flag_FUNCWEIGHT),
flag_GetFlagValue(Flags, flag_VARWEIGHT));
fputs("\n Precedence: ", stdout);
fol_PrintPrecedence(Precedence);
fputs("\n Ordering : ", stdout);
fputs(flag_GetFlagValue(Flags, flag_ORD) == flag_ORDKBO ? "KBO" : "RPOS",
stdout);
}
