void cont_TermPrintPrefix(CONTEXT GlobalContext, CONTEXT TermContext, TERM Term)
/**************************************************************
INPUT: A global context where index variables are bound,
a context and a term.
RETURNS: none.
SUMMARY: Prints the term modulo the context to stdout.
CAUTION: Variables of <Term1> are bound in
<TermContext1> and
the index variables are bound in <GlobalContext1>
***************************************************************/
{
Term = cont_Deref(GlobalContext,&TermContext, Term);
symbol_Print(term_TopSymbol(Term));
if (term_IsComplex(Term)) {
LIST List;
putchar('(');
for (List = term_ArgumentList(Term); !list_Empty(List);
List = list_Cdr(List)) {
cont_TermPrintPrefix(GlobalContext, TermContext, list_Car(List));
if (!list_Empty(list_Cdr(List)))
putchar(',');
}
putchar(')');
}
}
void cont_TermPrintPrefix(CONTEXT Context, TERM Term)
/**************************************************************
INPUT: A context and a term.
RETURNS: none.
SUMMARY: Prints the term modulo the context to stdout.
CAUTION: none.
***************************************************************/
{
Term = cont_Deref(&Context, Term);
symbol_Print(term_TopSymbol(Term));
if (term_IsComplex(Term)) {
LIST List;
putchar('(');
for (List = term_ArgumentList(Term); !list_Empty(List);
List = list_Cdr(List)) {
cont_TermPrintPrefix(Context, list_Car(List));
if (!list_Empty(list_Cdr(List)))
putchar(',');
}
putchar(')');
}
}
void symbol_PrintLn(SYMBOL Symbol)
/**************************************************************
INPUT: A symbol.
RETURNS: None.
SUMMARY: Prints a symbol and a newline to stdout.
***************************************************************/
{
symbol_Print(Symbol);
putchar('\n');
}
void cont_BindingOutput(CONTEXT C, SYMBOL Var)
{
symbol_Print(cont_ContextBindingSymbol(C, Var));
putchar(':');
symbol_Print(Var);
fputs(" -> ", stdout);
if (cont_VarIsBound(C, Var)) {
term_PrintPrefix(cont_ContextBindingTerm(C, Var));
} else
fputs("unbound", stdout);
fputs(" in ", stdout);
if (cont_VarIsUsed(C, Var)) {
printf("%ld", (unsigned long)cont_ContextBindingContext(C, Var));
} else
fputs("NULL (unused)", stdout);
fputs(". ", stdout);
if (cont_VarIsClosed(C, Var)) {
fputs("(closed)", stdout);
}
if (!cont_VarIsBound(C, Var) &&
!cont_VarIsUsed(C, Var)) {
fputs(",(free)", stdout);
}
if (cont_VarIsRenamed(C, Var)) {
fputs(",(renamed): ", stdout);
symbol_Print(Var);
fputs(" -> ", stdout);
symbol_Print(cont_ContextBindingRenaming(C, Var));
}
fflush(stdout);
}
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_GetFlagIntValue(Flags, flag_SATINPUT))
fputs("Input Saturation, ", stdout);
else
fputs("No Input Saturation, ", stdout);
if (flag_GetFlagIntValue(Flags, flag_SELECT) == flag_SELECTOFF)
fputs("No Selection, ", stdout);
else
if (flag_GetFlagIntValue(Flags, flag_SELECT) == flag_SELECTIFSEVERALMAXIMAL)
fputs("Dynamic Selection, ", stdout);
else
fputs("Always Selection, ", stdout);
if (flag_GetFlagIntValue(Flags, flag_SPLITS) == flag_SPLITSUNLIMITED)
fputs("Full Splitting, ", stdout);
else
if (flag_GetFlagIntValue(Flags, flag_SPLITS) == flag_SPLITSOFF)
fputs("No Splitting, ", stdout);
else
printf("Maximum of %d Splits, ",flag_GetFlagIntValue(Flags, flag_SPLITS));
if (flag_GetFlagIntValue(Flags, flag_FULLRED))
fputs("Full Reduction, ", stdout);
else
fputs("Lazy Reduction, ", stdout);
printf(" Ratio: %d, FuncWeight: %d, VarWeight: %d",
flag_GetFlagIntValue(Flags, flag_WDRATIO),
flag_GetFlagIntValue(Flags, flag_FUNCWEIGHT),
flag_GetFlagIntValue(Flags, flag_VARWEIGHT));
fputs("\n Precedence: ", stdout);
fol_PrintPrecedence(Precedence);
fputs("\n Ordering : ", stdout);
fputs(flag_GetFlagIntValue(Flags, flag_ORD) == flag_ORDKBO ? "KBO" : "RPOS",
stdout);
}
