void symbol_Init(BOOL Signature)
/**************************************************************
INPUT: A flag indicating whether a signature is used or not.
RETURNS: None.
SUMMARY: Initializes the Symbol Module.
EFFECTS: Initializes global variables.
CAUTION: MUST BE CALLED BEFORE ANY OTHER Symbol-FUNCTION.
***************************************************************/
{
symbol_ResetSkolemIndex();
symbol_ContextClean();
if (Signature)
symbol_SIGNATURE = (SIGNATURE*)memory_Malloc(sizeof(SIGNATURE[symbol__MAXSIGNATURE]));
symbol_STANDARDVARCOUNTER = symbol_GetInitialStandardVarCounter();
symbol_INDEXVARCOUNTER = symbol_GetInitialIndexVarCounter();
symbol_ACTINDEX = 1;
symbol_ORDERING = 1;
symbol_VARSTRING = memory_Malloc(symbol__SYMBOLMAXLEN);
symbol_HASSIGNATURE = Signature;
symbol_FREEDSYMBOLS = list_Nil();
}
TABLE table_Create(int opbound, int varbound, int termbound)
/***************************************************************
INPUT: bounds for the operator symbol, variable and term
indices of the terms to be stored in the signature
table (i. e. for every such term its top symbol index
has to be in [1, opbound] and the term numbers of its
arguments in [0, termbound] - or its variable index
in [1, varbound] if it is a variable)
RETURNS: a new (and empty) signature table
***************************************************************/
{
TABLE result;
#ifdef CHECK
if (opbound < 0) {
misc_StartErrorReport();
misc_ErrorReport("\n In table_Create: negative opbound.");
misc_FinishErrorReport();
}
if (varbound < 0) {
misc_StartErrorReport();
misc_ErrorReport("\n In table_Create: negative varbound.");
misc_FinishErrorReport();
}
if (termbound < 0) {
misc_StartErrorReport();
misc_ErrorReport("\n In table_Create: negative termbound.");
misc_FinishErrorReport();
}
#endif
result = (TABLE) memory_Malloc(sizeof(struct table));
table_SetTermarray(result, (TERMARRAY) memory_Calloc (
opbound + varbound + 1,
sizeof(struct termarray)
) + varbound);
/* move pointer to the middle of the array to allow negative indices */
table_SetPoss(
result,
(TERMARRAY*) memory_Malloc((termbound + 1) * sizeof(TERMARRAY))
);
table_SetPosstamps(result, (int*) memory_Calloc(termbound + 1, sizeof(int)));
table_SetOpbound(result, opbound);
table_SetVarbound(result, varbound);
table_SetTermbound(result, termbound);
table_SetStampcounter(result, 1);
return result;
}
void symbol_LowerSignature(void)
/**************************************************************
INPUT: None.
RETURNS: Nothing.
EFFECT: Any predicate or function symbol in the signature that
starts with a capital letter is prefixed with "ss"
***************************************************************/
{
int Index;
SIGNATURE Entry;
SYMBOL Info;
char* String;
for (Index = 1; Index < symbol_ACTINDEX; Index++) {
Entry = symbol_Signature(Index);
if (Entry != NULL) {
Info = Entry->info;
if (symbol_IsPredicate(Info) || symbol_IsFunction(Info)) {
String = Entry->name;
if ('A' <= String[0] && String[0] <= 'Z') {
char* New;
New = (char *)memory_Malloc(symbol__SYMBOLMAXLEN);
strcpy(&(New[2]),String);
New[0] = New[1] = 's'; /* prefix "ss" */
Entry->name = New;
memory_Free(String,symbol__SYMBOLMAXLEN);
}
}
}
}
}
TABPATH tab_PathCreate(int MaxLevel, TABLEAU Tab)
/**************************************************************
INPUT: A tableau, its maximum expected depth
RETURNS: A path consisting of the root node of the tableau
which can have a max length of <MaxLevel>
***************************************************************/
{
TABPATH TabPath;
TabPath = (TABPATH)memory_Malloc(sizeof(TABPATH_NODE));
TabPath->Path = (TABLEAU*)memory_Malloc(sizeof(TABLEAU)*(MaxLevel+1));
TabPath->Path[0] = Tab;
TabPath->MaxLength = MaxLevel;
TabPath->Length = 0;
return TabPath;
}
SYMBOL symbol_CreateFunction(const char* String, int Arity, int Status,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A string defining a symbol name, an arity, the status the
created function symbol is supposed to have and a precedence
object.
RETURNS: A new symbol for a new function.
SUMMARY: Creates a new function symbol.
EFFECTS: Inserts the new function in the symbol table.
The precedence of the new symbol is set in <Precedence>.
***************************************************************/
{
if (Arity == 0)
return symbol_SignatureCreate(strcpy(memory_Malloc(symbol__SYMBOLMAXLEN),
String),
symbol_CONSTANT, Arity, Status, Precedence);
else
return symbol_SignatureCreate(strcpy(memory_Malloc(symbol__SYMBOLMAXLEN),
String),
symbol_FUNCTION, Arity, Status, Precedence);
}
HASH hsh_Create(void)
/**************************************************************
RETURNS: A new, empty hasharray
***************************************************************/
{
HASH h;
NAT l;
h = (LIST*) memory_Malloc(sizeof(LIST) * hsh__SIZE);
for (l=0; l < hsh__SIZE; l++)
h[l] = list_Nil();
return h;
}
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;
}
SYMBOL symbol_CreateJunctor(const char* String, int Arity, int Status,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A string, a symbol arity, the status the created junctor
is supposed to have, and a precedence object.
RETURNS: A new symbol for a new junctor.
SUMMARY: Creates a new junctor symbol.
EFFECTS: Inserts the new junctor symbol into the symbol table.
The precedence of the new symbol is set in <Precedence>.
***************************************************************/
{
return symbol_SignatureCreate(strcpy(memory_Malloc(symbol__SYMBOLMAXLEN),
String),
symbol_JUNCTOR, Arity, Status, Precedence);
}
GRAPH graph_Create(void)
/**************************************************************
INPUT: None.
RETURNS: A new graph without nodes and edges.
***************************************************************/
{
GRAPH result;
result = memory_Malloc(sizeof(GRAPH_STRUCT));
result->size = 0;
result->dfscount = 0;
result->compcount = 0;
result->nodes = list_Nil();
return result;
}
CLITERAL literal_Create(BOOL used, int literal_index, LIST varlist)
/**********************************************************
INPUT: A boolean used, an integer index and a list varlist.
RETURNS: A LITERAL is created.
MEMORY: The boolean, integer and varlist are no copies.
************************************************************/
{
CLITERAL literal;
literal = (CLITERAL)memory_Malloc(sizeof(CLITERAL_NODE));
literal_PutUsed(literal,used);
literal_PutLitIndex(literal,literal_index);
literal_PutLitVarList(literal,varlist);
return literal;
}
GRAPHNODE graph_AddNode(GRAPH Graph, NAT Number)
/**************************************************************
INPUT: A graph and the ID of a node.
RETURNS: A node with the requested number.
EFFECT: If the graph has no such node, a new node is created.
***************************************************************/
{
GRAPHNODE result;
result = graph_GetNode(Graph, Number);
if (result == NULL) {
result = memory_Malloc(sizeof(GRAPHNODE_STRUCT));
Graph->nodes = list_Cons(result, Graph->nodes);
result->number = Number;
result->dfs_num = -1;
result->comp_num = -1;
result->info = NULL;
result->neighbors = list_Nil();
}
return result;
}
void cont_Init(void)
/**********************************************************
INPUT: None.
RETURNS: None.
EFFECT: Initializes the unify module.
********************************************************/
{
cont_LASTBINDING = (CONTEXT)NULL;
cont_ResetIndexVarScanner();
cont_NOOFCONTEXTS = 0;
cont_LISTOFCONTEXTS = list_Nil();
cont_BINDINGS = 0;
cont_INSTANCECONTEXT = (CONTEXT)memory_Malloc(sizeof(CONTEXT_NODE));
cont_LEFTCONTEXT = cont_Create();
cont_RIGHTCONTEXT = cont_Create();
cont_StackInit();
cont_StackPush(0);
cont_StackPop();
}
static void dp_FPrintDFGProof(LIST Clauses, const char *FilePrefix,
FLAGSTORE Flags, PRECEDENCE Precedence)
/*********************************************************
INPUT: A list of clauses representing a proof, a
string indicating a file name prefix, a flag
store and a precedence.
RETURNS: void.
EFFECT: Outputs the proof in DFG proof format to
<FilePrefix>.prf
**********************************************************/
{
FILE *Output;
CLAUSE Clause;
LIST AxClauses,ConClauses,ProofClauses,Scan;
char *name;
AxClauses = ConClauses = ProofClauses = list_Nil();
name = memory_Malloc(sizeof(char)*(strlen(FilePrefix)+5));
sprintf(name,"%s.prf", FilePrefix);
Output = misc_OpenFile(name,"w");
fputs("begin_problem(Unknown).\n\n", Output);
fputs("list_of_descriptions.\n", Output);
fputs("name({*", Output);
fputs(FilePrefix, Output);
fputs("*}).\n", Output);
fputs("author({*SPASS ", Output);
fputs(misc_VERSION, Output);
fputs("*}).\n", Output);
fputs("status(unsatisfiable).\n", Output);
fputs("description({*File generated by SPASS containing a proof.*}).\n", Output);
fputs("end_of_list.\n\n", Output);
fputs("list_of_symbols.\n", Output);
fol_FPrintDFGSignature(Output);
fputs("end_of_list.\n\n", Output);
for (Scan=Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
Clause = (CLAUSE)list_Car(Scan);
if (clause_IsFromInput(Clause)) {
if (clause_GetFlag(Clause, CONCLAUSE))
ConClauses = list_Cons(Clause, ConClauses);
else
AxClauses = list_Cons(Clause, AxClauses);
}
else
ProofClauses = list_Cons(Clause, ProofClauses);
}
ConClauses = list_NReverse(ConClauses);
AxClauses = list_NReverse(AxClauses);
ProofClauses = list_NReverse(ProofClauses);
clause_FPrintCnfDFG(Output, FALSE, AxClauses, ConClauses, Flags, Precedence);
fputs("\nlist_of_proof(SPASS).\n", Output);
for (Scan=ProofClauses; !list_Empty(Scan); Scan=list_Cdr(Scan)) {
clause_FPrintDFGStep(Output,list_Car(Scan),TRUE);
}
fputs("end_of_list.\n\n", Output);
fputs("end_problem.\n\n", Output);
misc_CloseFile(Output, name);
fputs("\nDFG Proof printed to: ", stdout);
puts(name);
list_Delete(ConClauses);
list_Delete(AxClauses);
list_Delete(ProofClauses);
memory_Free(name, sizeof(char)*(strlen(FilePrefix)+5));
}
