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)); }