自学教程：C++ Bloaded函数代码示例

/***************************************************  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  }