/*************************************************** NAME : EnvIsDefmessageHandlerDeletable DESCRIPTION : Determines if a message-handler can be deleted INPUTS : 1) Address of the handler's class 2) Index of the handler RETURNS : TRUE if deletable, FALSE otherwise SIDE EFFECTS : None NOTES : None ***************************************************/ globle int EnvIsDefmessageHandlerDeletable( void *theEnv, void *ptr, unsigned theIndex) { #if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY) #pragma unused(theEnv,ptr,theIndex) #endif #if BLOAD_ONLY || RUN_TIME return(FALSE); #else DEFCLASS *cls; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif cls = (DEFCLASS *) ptr; if (cls->handlers[theIndex-1].system == 1) return(FALSE); return((HandlersExecuting(cls) == FALSE) ? TRUE : FALSE); #endif }
static void DeallocateDeffactsData( void *theEnv) { #if ! RUN_TIME struct deffactsModule *theModuleItem; void *theModule; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return; #endif DoForAllConstructs(theEnv,DestroyDeffactsAction,DeffactsData(theEnv)->DeffactsModuleIndex,FALSE,NULL); for (theModule = EnvGetNextDefmodule(theEnv,NULL); theModule != NULL; theModule = EnvGetNextDefmodule(theEnv,theModule)) { theModuleItem = (struct deffactsModule *) GetModuleItem(theEnv,(struct defmodule *) theModule, DeffactsData(theEnv)->DeffactsModuleIndex); rtn_struct(theEnv,deffactsModule,theModuleItem); } #else #if MAC_MCW || WIN_MCW || MAC_XCD #pragma unused(theEnv) #endif #endif }
/*************************************************** NAME : RemoveAllDefinstances DESCRIPTION : Removes all definstances constructs INPUTS : None RETURNS : TRUE if successful, FALSE otherwise SIDE EFFECTS : All definstances deallocated NOTES : None ***************************************************/ static intBool RemoveAllDefinstances( void *theEnv) { DEFINSTANCES *dptr,*dhead; int success = TRUE; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif dhead = (DEFINSTANCES *) EnvGetNextDefinstances(theEnv,NULL); while (dhead != NULL) { dptr = dhead; dhead = (DEFINSTANCES *) EnvGetNextDefinstances(theEnv,(void *) dhead); if (EnvIsDefinstancesDeletable(theEnv,(void *) dptr)) { RemoveConstructFromModule(theEnv,(struct constructHeader *) dptr); RemoveDefinstances(theEnv,(void *) dptr); } else { DefinstancesDeleteError(theEnv,EnvGetDefinstancesName(theEnv,(void *) dptr)); success = FALSE; } } return(success); }
/*********************************************************** NAME : EnvUndefinstances DESCRIPTION : Removes a definstance INPUTS : Address of definstances to remove RETURNS : TRUE if successful, FALSE otherwise SIDE EFFECTS : Definstance deallocated NOTES : None ***********************************************************/ globle intBool EnvUndefinstances( void *theEnv, void *vptr) { #if RUN_TIME || BLOAD_ONLY #if MAC_MCW || WIN_MCW || MAC_XCD #pragma unused(theEnv,vptr) #endif return(FALSE); #else DEFINSTANCES *dptr; dptr = (DEFINSTANCES *) vptr; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif if (dptr == NULL) return(RemoveAllDefinstances(theEnv)); if (EnvIsDefinstancesDeletable(theEnv,vptr) == FALSE) return(FALSE); RemoveConstructFromModule(theEnv,(struct constructHeader *) vptr); RemoveDefinstances(theEnv,(void *) dptr); return(TRUE); #endif }
globle CLIPS_BOOLEAN EnvIsDefruleDeletable( void *theEnv, void *vTheDefrule) { #if BLOAD_ONLY || RUN_TIME #if MAC_MCW || IBM_MCW || MAC_XCD #pragma unused(theEnv,vTheDefrule) #endif return(FALSE); #else struct defrule *theDefrule; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif for (theDefrule = (struct defrule *) vTheDefrule; theDefrule != NULL; theDefrule = theDefrule->disjunct) { if (theDefrule->executing) return(FALSE); } if (EngineData(theEnv)->JoinOperationInProgress) return(FALSE); return(TRUE); #endif }
/*************************************************** NAME : EnvUndeffunction DESCRIPTION : External interface routine for removing a deffunction INPUTS : Deffunction pointer RETURNS : FALSE if unsuccessful, TRUE otherwise SIDE EFFECTS : Deffunction deleted, if possible NOTES : None ***************************************************/ globle intBool EnvUndeffunction( void *theEnv, EXEC_STATUS, void *vptr) { #if (MAC_MCW || WIN_MCW) && (RUN_TIME || BLOAD_ONLY) #pragma unused(theEnv,execStatus,vptr) #endif #if BLOAD_ONLY || RUN_TIME return(FALSE); #else #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv,execStatus) == TRUE) return(FALSE); #endif if (vptr == NULL) return(RemoveAllDeffunctions(theEnv,execStatus)); if (EnvIsDeffunctionDeletable(theEnv,execStatus,vptr) == FALSE) return(FALSE); RemoveConstructFromModule(theEnv,execStatus,(struct constructHeader *) vptr); RemoveDeffunction(theEnv,execStatus,vptr); return(TRUE); #endif }
static void DeallocateDefglobalData( void *theEnv) { #if ! RUN_TIME struct defglobalModule *theModuleItem; void *theModule; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return; #endif DoForAllConstructs(theEnv,DestroyDefglobalAction,DefglobalData(theEnv)->DefglobalModuleIndex,FALSE,NULL); for (theModule = EnvGetNextDefmodule(theEnv,NULL); theModule != NULL; theModule = EnvGetNextDefmodule(theEnv,theModule)) { theModuleItem = (struct defglobalModule *) GetModuleItem(theEnv,(struct defmodule *) theModule, DefglobalData(theEnv)->DefglobalModuleIndex); rtn_struct(theEnv,defglobalModule,theModuleItem); } #else DoForAllConstructs(theEnv,DestroyDefglobalAction,DefglobalData(theEnv)->DefglobalModuleIndex,FALSE,NULL); #endif }
/**************************************************************** NAME : ClearDefgenerics DESCRIPTION : Deletes all generic headers INPUTS : None RETURNS : TRUE if all methods deleted, FALSE otherwise SIDE EFFECTS : Generic headers deleted (and any implicit system function methods) NOTES : None ****************************************************************/ globle int ClearDefgenerics( void *theEnv) { register DEFGENERIC *gfunc,*gtmp; int success = TRUE; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv) == TRUE) return(FALSE); #endif gfunc = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,NULL); while (gfunc != NULL) { gtmp = gfunc; gfunc = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,(void *) gfunc); if (RemoveAllExplicitMethods(theEnv,gtmp) == FALSE) { CantDeleteItemErrorMessage(theEnv,(char*)"generic function",EnvGetDefgenericName(theEnv,gtmp)); success = FALSE; } else { RemoveConstructFromModule(theEnv,(struct constructHeader *) gtmp); RemoveDefgeneric(theEnv,(void *) gtmp); } } return(success); }
/*************************************************** NAME : RemoveAllDeffunctions DESCRIPTION : Removes all deffunctions INPUTS : None RETURNS : TRUE if all deffunctions removed, FALSE otherwise SIDE EFFECTS : Deffunctions removed NOTES : None ***************************************************/ static intBool RemoveAllDeffunctions( void *theEnv, EXEC_STATUS) { DEFFUNCTION *dptr,*dtmp; unsigned oldbusy; intBool success = TRUE; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv,execStatus) == TRUE) return(FALSE); #endif dptr = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,execStatus,NULL); while (dptr != NULL) { if (dptr->executing > 0) { DeffunctionDeleteError(theEnv,execStatus,EnvGetDeffunctionName(theEnv,execStatus,(void *) dptr)); success = FALSE; } else { oldbusy = dptr->busy; ExpressionDeinstall(theEnv,execStatus,dptr->code); dptr->busy = oldbusy; ReturnPackedExpression(theEnv,execStatus,dptr->code); dptr->code = NULL; } dptr = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,execStatus,(void *) dptr); } dptr = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,execStatus,NULL); while (dptr != NULL) { dtmp = dptr; dptr = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,execStatus,(void *) dptr); if (dtmp->executing == 0) { if (dtmp->busy > 0) { PrintWarningID(theEnv,execStatus,"DFFNXFUN",1,FALSE); EnvPrintRouter(theEnv,execStatus,WWARNING,"Deffunction "); EnvPrintRouter(theEnv,execStatus,WWARNING,EnvGetDeffunctionName(theEnv,execStatus,(void *) dtmp)); EnvPrintRouter(theEnv,execStatus,WWARNING," only partially deleted due to usage by other constructs.\n"); SetDeffunctionPPForm((void *) dtmp,NULL); success = FALSE; } else { RemoveConstructFromModule(theEnv,execStatus,(struct constructHeader *) dtmp); RemoveDeffunction(theEnv,execStatus,dtmp); } } } return(success); }
static void BsaveFind() { struct defglobal *defglobalPtr; struct defmodule *theModule; /*=======================================================*/ /* If a binary image is already loaded, then temporarily */ /* save the count values since these will be overwritten */ /* in the process of saving the binary image. */ /*=======================================================*/ if (Bloaded()) { SaveBloadCount(NumberOfDefglobalModules); SaveBloadCount(NumberOfDefglobals); } /*============================================*/ /* Set the count of defglobals and defglobals */ /* module data structures to zero. */ /*============================================*/ NumberOfDefglobals = 0; NumberOfDefglobalModules = 0; for (theModule = (struct defmodule *) GetNextDefmodule(NULL); theModule != NULL; theModule = (struct defmodule *) GetNextDefmodule(theModule)) { /*================================================*/ /* Set the current module to the module being */ /* examined and increment the number of defglobal */ /* modules encountered. */ /*================================================*/ SetCurrentModule((void *) theModule); NumberOfDefglobalModules++; /*====================================================*/ /* Loop through each defglobal in the current module. */ /*====================================================*/ for (defglobalPtr = (struct defglobal *) GetNextDefglobal(NULL); defglobalPtr != NULL; defglobalPtr = (struct defglobal *) GetNextDefglobal(defglobalPtr)) { /*======================================================*/ /* Initialize the construct header for the binary save. */ /*======================================================*/ MarkConstructHeaderNeededItems(&defglobalPtr->header,NumberOfDefglobals++); } } }
static void DeallocateObjectReteData( void *theEnv) { OBJECT_PATTERN_NODE *theNetwork; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return; #endif theNetwork = ObjectReteData(theEnv)->ObjectPatternNetworkPointer; DestroyObjectPatternNetwork(theEnv,theNetwork); }
/*************************************************************************** NAME : BsaveDeffunctionFind DESCRIPTION : For all deffunctions, this routine marks all the needed symbols. Also, it also counts the number of expression structures needed. Also, counts total number of deffunctions. INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented for every expression needed Symbols are marked in their structures NOTES : Also sets bsaveIndex for each deffunction (assumes deffunctions will be bsaved in order of binary list) ***************************************************************************/ static void BsaveDeffunctionFind() { if (Bloaded()) { SaveBloadCount(ModuleCount); SaveBloadCount(DeffunctionCount); } DeffunctionCount = 0L; ModuleCount = DoForAllConstructs(MarkDeffunctionItems,DeffunctionModuleIndex, FALSE,NULL); }
static void DeallocateExpressionData( void *theEnv) { #if ! RUN_TIME int i; EXPRESSION_HN *tmpPtr, *nextPtr; #if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) if (! Bloaded(theEnv)) #endif { for (i = 0; i < EXPRESSION_HASH_SIZE; i++) { tmpPtr = ExpressionData(theEnv)->ExpressionHashTable[i]; while (tmpPtr != NULL) { nextPtr = tmpPtr->next; ReturnPackedExpression(theEnv,tmpPtr->exp); rtn_struct(theEnv,exprHashNode,tmpPtr); tmpPtr = nextPtr; } } } rm(theEnv,ExpressionData(theEnv)->ExpressionHashTable, (int) (sizeof(EXPRESSION_HN *) * EXPRESSION_HASH_SIZE)); #else #if MAC_MCW || WIN_MCW || MAC_XCD #pragma unused(theEnv) #endif #endif #if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) if ((ExpressionData(theEnv)->NumberOfExpressions != 0) && Bloaded(theEnv)) { genfree(theEnv,(void *) ExpressionData(theEnv)->ExpressionArray, ExpressionData(theEnv)->NumberOfExpressions * sizeof(struct expr)); } #endif }
static void DeallocateDefruleData( Environment *theEnv) { struct defruleModule *theModuleItem; Defmodule *theModule; Activation *theActivation, *tmpActivation; struct salienceGroup *theGroup, *tmpGroup; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) { return; } #endif DoForAllConstructs(theEnv,DestroyDefruleAction, DefruleData(theEnv)->DefruleModuleIndex,false,NULL); for (theModule = GetNextDefmodule(theEnv,NULL); theModule != NULL; theModule = GetNextDefmodule(theEnv,theModule)) { theModuleItem = (struct defruleModule *) GetModuleItem(theEnv,theModule, DefruleData(theEnv)->DefruleModuleIndex); theActivation = theModuleItem->agenda; while (theActivation != NULL) { tmpActivation = theActivation->next; rtn_struct(theEnv,activation,theActivation); theActivation = tmpActivation; } theGroup = theModuleItem->groupings; while (theGroup != NULL) { tmpGroup = theGroup->next; rtn_struct(theEnv,salienceGroup,theGroup); theGroup = tmpGroup; } #if ! RUN_TIME rtn_struct(theEnv,defruleModule,theModuleItem); #endif } rm(theEnv,DefruleData(theEnv)->AlphaMemoryTable,sizeof (ALPHA_MEMORY_HASH *) * ALPHA_MEMORY_HASH_SIZE); }
static void ClearDefmodules( void *theEnv) { #if (BLOAD || BLOAD_AND_BSAVE || BLOAD_ONLY) && (! RUN_TIME) if (Bloaded(theEnv) == TRUE) return; #endif #if (! RUN_TIME) RemoveAllDefmodules(theEnv); CreateMainModule(theEnv); DefmoduleData(theEnv)->MainModuleRedefinable = TRUE; #else #endif }
/*************************************************************************** NAME : BsaveObjectsFind DESCRIPTION : For all classes and their message-handlers, this routine marks all the needed symbols and system functions. Also, it also counts the number of expression structures needed. INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented for every expression needed Symbols are marked in their structures NOTES : Also sets bsaveIndex for each class (assumes classes will be bsaved in order of binary list) ***************************************************************************/ static void BsaveObjectsFind() { register unsigned i; SLOT_NAME *snp; /* ======================================================== The counts need to be saved in case a bload is in effect ======================================================== */ if (Bloaded()) { SaveBloadCount(ModuleCount); SaveBloadCount(ClassCount); SaveBloadCount(LinkCount); SaveBloadCount(SlotNameCount); SaveBloadCount(SlotCount); SaveBloadCount(TemplateSlotCount); SaveBloadCount(SlotNameMapCount); SaveBloadCount(HandlerCount); } ModuleCount= 0L; ClassCount = 0L; SlotCount = 0L; SlotNameCount = 0L; LinkCount = 0L; TemplateSlotCount = 0L; SlotNameMapCount = 0L; HandlerCount = 0L; /* ============================================== Mark items needed by defclasses in all modules ============================================== */ ModuleCount = DoForAllConstructs(MarkDefclassItems,DefclassModuleIndex, FALSE,NULL); /* ============================================= Mark items needed by canonicalized slot names ============================================= */ for (i = 0 ; i < SLOT_NAME_TABLE_HASH_SIZE ; i++) for (snp = SlotNameTable[i] ; snp != NULL ; snp = snp->nxt) { if ((snp->id != ISA_ID) && (snp->id != NAME_ID)) { snp->bsaveIndex = SlotNameCount++; snp->name->neededSymbol = TRUE; snp->putHandlerName->neededSymbol = TRUE; } } }
/*********************************************************** NAME : EnvUndefmessageHandler DESCRIPTION : Deletes a handler from a class INPUTS : 1) Class address (Can be NULL) 2) Handler index (can be 0) RETURNS : 1 if successful, 0 otherwise SIDE EFFECTS : Handler deleted if possible NOTES : None ***********************************************************/ globle int EnvUndefmessageHandler( void *theEnv, void *vptr, unsigned mhi) { #if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY) #pragma unused(vptr) #pragma unused(mhi) #endif #if RUN_TIME || BLOAD_ONLY PrintErrorID(theEnv,"MSGCOM",3,FALSE); EnvPrintRouter(theEnv,WERROR,"Unable to delete message-handlers.\n"); return(0); #else DEFCLASS *cls; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) { PrintErrorID(theEnv,"MSGCOM",3,FALSE); EnvPrintRouter(theEnv,WERROR,"Unable to delete message-handlers.\n"); return(0); } #endif if (vptr == NULL) { if (mhi != 0) { PrintErrorID(theEnv,"MSGCOM",1,FALSE); EnvPrintRouter(theEnv,WERROR,"Incomplete message-handler specification for deletion.\n"); return(0); } return(WildDeleteHandler(theEnv,NULL,NULL,NULL)); } if (mhi == 0) return(WildDeleteHandler(theEnv,(DEFCLASS *) vptr,NULL,NULL)); cls = (DEFCLASS *) vptr; if (HandlersExecuting(cls)) { HandlerDeleteError(theEnv,EnvGetDefclassName(theEnv,(void *) cls)); return(0); } cls->handlers[mhi-1].mark = 1; DeallocateMarkedHandlers(theEnv,cls); return(1); #endif }
static void ClearDefmodules( void *theEnv) { #if (BLOAD || BLOAD_AND_BSAVE || BLOAD_ONLY) && (! RUN_TIME) if (Bloaded(theEnv) == true) return; #endif #if (! RUN_TIME) RemoveAllDefmodules(theEnv); CreateMainModule(theEnv); DefmoduleData(theEnv)->MainModuleRedefinable = true; #else #if MAC_XCD #pragma unused(theEnv) #endif #endif }
/************************************************************ NAME : ClearDefmethods DESCRIPTION : Deletes all defmethods - generic headers are left intact INPUTS : None RETURNS : TRUE if all methods deleted, FALSE otherwise SIDE EFFECTS : Defmethods deleted NOTES : Clearing generic functions is done in two stages 1) Delete all methods (to clear any references to other constructs) 2) Delete all generic headers This allows other constructs which mutually refer to generic functions to be cleared ************************************************************/ globle int ClearDefmethods() { register DEFGENERIC *gfunc; int success = TRUE; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded() == TRUE) return(FALSE); #endif gfunc = (DEFGENERIC *) GetNextDefgeneric(NULL); while (gfunc != NULL) { if (RemoveAllExplicitMethods(gfunc) == FALSE) success = FALSE; gfunc = (DEFGENERIC *) GetNextDefgeneric((void *) gfunc); } return(success); }
/*************************************************** NAME : EnvIsDefinstancesDeletable DESCRIPTION : Determines if a definstances can be deleted INPUTS : Address of the definstances RETURNS : TRUE if deletable, FALSE otherwise SIDE EFFECTS : None NOTES : None ***************************************************/ globle int EnvIsDefinstancesDeletable( void *theEnv, void *ptr) { #if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY) #pragma unused(theEnv,ptr) #endif #if BLOAD_ONLY || RUN_TIME return(FALSE); #else #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif return((((DEFINSTANCES *) ptr)->busy == 0) ? TRUE : FALSE); #endif }
/*************************************************************************** NAME : BsaveGenericsFind DESCRIPTION : For all generic functions and their methods, this routine marks all the needed symbols and system functions. Also, it also counts the number of expression structures needed. Also, counts total number of generics, methods, restrictions and types. INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented for every expression needed Symbols and system function are marked in their structures NOTES : Also sets bsaveIndex for each generic function (assumes generic functions will be bsaved in order of binary list) ***************************************************************************/ static void BsaveGenericsFind() { if (Bloaded()) { SaveBloadCount(ModuleCount); SaveBloadCount(GenericCount); SaveBloadCount(MethodCount); SaveBloadCount(RestrictionCount); SaveBloadCount(TypeCount); } GenericCount = 0L; MethodCount = 0L; RestrictionCount = 0L; TypeCount = 0L; ModuleCount = DoForAllConstructs(MarkDefgenericItems,DefgenericModuleIndex, FALSE,NULL); }
/****************************************************************************** NAME : UndefmessageHandlerCommand DESCRIPTION : Deletes a handler from a class INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : Handler deleted if possible NOTES : H/L Syntax: (undefmessage-handler <class> <handler> [<type>]) ******************************************************************************/ globle void UndefmessageHandlerCommand( void *theEnv) { #if RUN_TIME || BLOAD_ONLY PrintErrorID(theEnv,"MSGCOM",3,FALSE); EnvPrintRouter(theEnv,WERROR,"Unable to delete message-handlers.\n"); #else SYMBOL_HN *mname; const char *tname; DATA_OBJECT tmp; DEFCLASS *cls; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) { PrintErrorID(theEnv,"MSGCOM",3,FALSE); EnvPrintRouter(theEnv,WERROR,"Unable to delete message-handlers.\n"); return; } #endif if (EnvArgTypeCheck(theEnv,"undefmessage-handler",1,SYMBOL,&tmp) == FALSE) return; cls = LookupDefclassByMdlOrScope(theEnv,DOToString(tmp)); if ((cls == NULL) ? (strcmp(DOToString(tmp),"*") != 0) : FALSE) { ClassExistError(theEnv,"undefmessage-handler",DOToString(tmp)); return; } if (EnvArgTypeCheck(theEnv,"undefmessage-handler",2,SYMBOL,&tmp) == FALSE) return; mname = (SYMBOL_HN *) tmp.value; if (EnvRtnArgCount(theEnv) == 3) { if (EnvArgTypeCheck(theEnv,"undefmessage-handler",3,SYMBOL,&tmp) == FALSE) return; tname = DOToString(tmp); if (strcmp(tname,"*") == 0) tname = NULL; } else tname = MessageHandlerData(theEnv)->hndquals[MPRIMARY]; WildDeleteHandler(theEnv,cls,mname,tname); #endif }
/******************************************************** NAME : EnvUndefclass DESCRIPTION : Deletes the named defclass INPUTS : None RETURNS : TRUE if deleted, or FALSE SIDE EFFECTS : Defclass and handlers removed NOTES : Interface for AddConstruct() ********************************************************/ globle intBool EnvUndefclass( void *theEnv, void *theDefclass) { #if RUN_TIME || BLOAD_ONLY return(FALSE); #else DEFCLASS *cls; cls = (DEFCLASS *) theDefclass; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif if (cls == NULL) return(RemoveAllUserClasses(theEnv)); return(DeleteClassUAG(theEnv,cls)); #endif }
/************************************************************ NAME : ClearDefmethods DESCRIPTION : Deletes all defmethods - generic headers are left intact INPUTS : None RETURNS : TRUE if all methods deleted, FALSE otherwise SIDE EFFECTS : Defmethods deleted NOTES : Clearing generic functions is done in two stages 1) Delete all methods (to clear any references to other constructs) 2) Delete all generic headers This allows other constructs which mutually refer to generic functions to be cleared ************************************************************/ globle int ClearDefmethods( void *theEnv, EXEC_STATUS) { register DEFGENERIC *gfunc; int success = TRUE; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv,execStatus) == TRUE) return(FALSE); #endif gfunc = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,execStatus,NULL); while (gfunc != NULL) { if (RemoveAllExplicitMethods(theEnv,execStatus,gfunc) == FALSE) success = FALSE; gfunc = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,execStatus,(void *) gfunc); } return(success); }
static void DeallocateDefruleData( void *theEnv) { struct defruleModule *theModuleItem; void *theModule; struct activation *theActivation, *tmpActivation; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return; #endif DoForAllConstructs(theEnv,DestroyDefruleAction,DefruleData(theEnv)->DefruleModuleIndex,FALSE,NULL); for (theModule = EnvGetNextDefmodule(theEnv,NULL); theModule != NULL; theModule = EnvGetNextDefmodule(theEnv,theModule)) { theModuleItem = (struct defruleModule *) GetModuleItem(theEnv,(struct defmodule *) theModule, DefruleData(theEnv)->DefruleModuleIndex); theActivation = theModuleItem->agenda; while (theActivation != NULL) { tmpActivation = theActivation->next; #if CONFLICT_RESOLUTION_STRATEGIES if (theActivation->sortedBasis != NULL) { DestroyPartialMatch(theEnv,theActivation->sortedBasis); } #endif rtn_struct(theEnv,activation,theActivation); theActivation = tmpActivation; } #if ! RUN_TIME rtn_struct(theEnv,defruleModule,theModuleItem); #endif } }
globle BOOLEAN EnvIsDeffactsDeletable( void *theEnv, void *ptr) { #if MAC_MCW || IBM_MCW #pragma unused(ptr) #endif #if BLOAD_ONLY || RUN_TIME #if MAC_MCW || IBM_MCW #pragma unused(theEnv) #endif return(FALSE); #else #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif if (ConstructData(theEnv)->ResetInProgress) return(FALSE); return(TRUE); #endif }
/*************************************************** NAME : BsaveObjectPatternsFind DESCRIPTION : Sets the Bsave IDs for the object pattern data structures and determines how much space (including padding) is necessary for the alpha node bitmPS INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : Counts written NOTES : None ***************************************************/ static void BsaveObjectPatternsFind() { OBJECT_ALPHA_NODE *alphaPtr; OBJECT_PATTERN_NODE *patternPtr; if (Bloaded()) { SaveBloadCount(AlphaNodeCount); SaveBloadCount(PatternNodeCount); } AlphaNodeCount = 0L; alphaPtr = ObjectNetworkTerminalPointer(); while (alphaPtr != NULL) { alphaPtr->classbmp->neededBitMap = TRUE; if (alphaPtr->slotbmp != NULL) alphaPtr->slotbmp->neededBitMap = TRUE; alphaPtr->bsaveID = AlphaNodeCount++; alphaPtr = alphaPtr->nxtTerminal; } PatternNodeCount = 0L; patternPtr = ObjectNetworkPointer(); while (patternPtr != NULL) { patternPtr->bsaveID = PatternNodeCount++; if (patternPtr->nextLevel == NULL) { while (patternPtr->rightNode == NULL) { patternPtr = patternPtr->lastLevel; if (patternPtr == NULL) return; } patternPtr = patternPtr->rightNode; } else patternPtr = patternPtr->nextLevel; } }
/************************************************************************************* NAME : BsaveDeffunctions DESCRIPTION : Writes out deffunction in binary format Space required (unsigned long) All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions) INPUTS : File pointer of binary file RETURNS : Nothing useful SIDE EFFECTS : Binary file adjusted NOTES : None *************************************************************************************/ static void BsaveDeffunctions( FILE *fp) { unsigned long space; struct defmodule *theModule; DEFFUNCTION_MODULE *theModuleItem; BSAVE_DEFFUNCTION_MODULE dummy_mitem; space = (unsigned long) ((sizeof(BSAVE_DEFFUNCTION_MODULE) * ModuleCount) + (sizeof(BSAVE_DEFFUNCTION) * DeffunctionCount)); GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp); /* ================================= Write out each deffunction module ================================= */ DeffunctionCount = 0L; theModule = (struct defmodule *) GetNextDefmodule(NULL); while (theModule != NULL) { theModuleItem = (DEFFUNCTION_MODULE *) GetModuleItem(theModule,FindModuleItem("deffunction")->moduleIndex); AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header); GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFFUNCTION_MODULE),fp); theModule = (struct defmodule *) GetNextDefmodule((void *) theModule); } /* ========================== Write out each deffunction ========================== */ DoForAllConstructs(BsaveDeffunction,DeffunctionModuleIndex, FALSE,(void *) fp); if (Bloaded()) { RestoreBloadCount(&ModuleCount); RestoreBloadCount(&DeffunctionCount); } }
/*************************************************** NAME : EnvUndeffunction DESCRIPTION : External interface routine for removing a deffunction INPUTS : Deffunction pointer RETURNS : FALSE if unsuccessful, TRUE otherwise SIDE EFFECTS : Deffunction deleted, if possible NOTES : None ***************************************************/ globle intBool EnvUndeffunction( void *theEnv, void *vptr) { #if BLOAD_ONLY || RUN_TIME return(FALSE); #else #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv) == TRUE) return(FALSE); #endif if (vptr == NULL) return(RemoveAllDeffunctions(theEnv)); if (EnvIsDeffunctionDeletable(theEnv,vptr) == FALSE) return(FALSE); RemoveConstructFromModule(theEnv,(struct constructHeader *) vptr); RemoveDeffunction(theEnv,vptr); return(TRUE); #endif }
globle BOOLEAN EnvIsDeftemplateDeletable( void *theEnv, void *vTheDeftemplate) { #if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY) #pragma unused(theEnv,vTheDeftemplate) #endif #if BLOAD_ONLY || RUN_TIME return(FALSE); #else struct deftemplate *theDeftemplate = (struct deftemplate *) vTheDeftemplate; #if BLOAD || BLOAD_AND_BSAVE if (Bloaded(theEnv)) return(FALSE); #endif if (theDeftemplate->busyCount > 0) return(FALSE); if (theDeftemplate->patternNetwork != NULL) return(FALSE); return(TRUE); #endif }