genrcbin.c

NASA 开发使用的一个专家系统

         if (rptr->query != NULL)
           {
            dummy_restriction.query = ExpressionCount;
            ExpressionCount += ExpressionSize(rptr->query);
           }
         else
           dummy_restriction.query = -1L;
         GenWrite((VOID *) &dummy_restriction,
                  (unsigned long) sizeof(BSAVE_RESTRICTION),(FILE *) userBuffer);
        }
     }
  }
  
/*************************************************************
  NAME         : BsaveRestrictionTypes
  DESCRIPTION  : Bsaves defgeneric methods' retrictions' types
  INPUTS       : 1) The defgeneric
                 2) Output data file pointer
  RETURNS      : Nothing useful
  SIDE EFFECTS : Defgeneric methods' restrictions' types saved
  NOTES        : None
 *************************************************************/
static VOID BsaveRestrictionTypes(theDefgeneric,userBuffer)
  struct constructHeader *theDefgeneric;
  VOID *userBuffer;
  {
   DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
   long dummy_type;
   RESTRICTION *rptr;
   register unsigned i,j,k;

   for (i = 0 ; i < gfunc->mcnt ; i++)
     {
      for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++)
        {
         rptr = &gfunc->methods[i].restrictions[j];
         for (k = 0 ; k < rptr->tcnt ; k++)
           {
#if OBJECT_SYSTEM
            dummy_type = DefclassIndex(rptr->types[k]);
#else
            dummy_type = (long) ((INTEGER_HN *) rptr->types[k])->contents;
#endif
            GenWrite(&dummy_type,(unsigned long) sizeof(long),(FILE *) userBuffer);
           }
        }
     }
  }
  
#endif

/***********************************************************************
  NAME         : BloadStorageGenerics
  DESCRIPTION  : This routine space required for generic function
                   structures and allocates space for them
  INPUTS       : Nothing
  RETURNS      : Nothing useful
  SIDE EFFECTS : Arrays allocated and set
  NOTES        : This routine makes no attempt to reset any pointers
                   within the structures
 ***********************************************************************/
static VOID BloadStorageGenerics()
  {
   unsigned long space;
   long counts[5];
   
   GenRead((VOID *) &space,(unsigned long) sizeof(unsigned long));
   if (space == 0L)
     return;
   GenRead((VOID *) counts,space);
   ModuleCount = counts[0];
   GenericCount = counts[1];
   MethodCount = counts[2];
   RestrictionCount = counts[3];
   TypeCount = counts[4];
   if (ModuleCount != 0L)
     {
      space = (unsigned long) (sizeof(DEFGENERIC_MODULE) * ModuleCount);
      ModuleArray = (DEFGENERIC_MODULE HUGE_ADDR *) genlongalloc(space);
     }
   else
     return;
   if (GenericCount != 0L)
     {
      space = (unsigned long) (sizeof(DEFGENERIC) * GenericCount);
      defgenericArray = (DEFGENERIC HUGE_ADDR *) genlongalloc(space);
     }
   else
     return;
   if (MethodCount != 0L)
     {
      space = (unsigned long) (sizeof(DEFMETHOD) * MethodCount);
      methodArray = (DEFMETHOD HUGE_ADDR *) genlongalloc(space);
     }
   else
     return;
   if (RestrictionCount != 0L)
     {
      space = (unsigned long) (sizeof(RESTRICTION) * RestrictionCount);
      restrictionArray = (RESTRICTION HUGE_ADDR *) genlongalloc(space);
     }
   else
     return;
   if (TypeCount != 0L)
     {
      space = (unsigned long) (sizeof(VOID *) * TypeCount);
      typeArray = (VOID * HUGE_ADDR *) genlongalloc(space);
     }
  }

/*********************************************************************
  NAME         : BloadGenerics
  DESCRIPTION  : This routine reads generic function information from
                 a binary file in four chunks:
                 Generic-header array
                 Method array
                 Method restrictions array
                 Restriction types array
                 
                 This routine moves through the generic function
                   binary arrays updating pointers
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : Pointers reset from array indices
  NOTES        : Assumes all loading is finished
 ********************************************************************/
static VOID BloadGenerics()
  {
   unsigned long space;
   
   GenRead((VOID *) &space,(unsigned long) sizeof(unsigned long));
   if (ModuleCount == 0L)
     return;
   BloadandRefresh(ModuleCount,(unsigned) sizeof(BSAVE_DEFGENERIC_MODULE),UpdateGenericModule);
   if (GenericCount == 0L)
     return;
   BloadandRefresh(GenericCount,(unsigned) sizeof(BSAVE_GENERIC),UpdateGeneric);
   BloadandRefresh(MethodCount,(unsigned) sizeof(BSAVE_METHOD),UpdateMethod);
   BloadandRefresh(RestrictionCount,(unsigned) sizeof(BSAVE_RESTRICTION),UpdateRestriction);
   BloadandRefresh(TypeCount,(unsigned) sizeof(long),UpdateType);
  }

/*********************************************
  Bload update routines for generic structures
 *********************************************/
static VOID UpdateGenericModule(buf,obji)
  VOID *buf;
  long obji;
  {
   BSAVE_DEFGENERIC_MODULE *bdptr;
   
   bdptr = (BSAVE_DEFGENERIC_MODULE *) buf;
   UpdateDefmoduleItemHeader(&bdptr->header,&ModuleArray[obji].header,
                             (int) sizeof(DEFGENERIC),(VOID *) defgenericArray);
  }
  
static VOID UpdateGeneric(buf,obji)
  VOID *buf;
  long obji;
  {
   BSAVE_GENERIC *bgp;
   DEFGENERIC *gp;
   
   bgp = (BSAVE_GENERIC *) buf;
   gp = (DEFGENERIC *) &defgenericArray[obji];
   
   UpdateConstructHeader(&bgp->header,&gp->header,
                         (int) sizeof(DEFGENERIC_MODULE),(VOID *) ModuleArray,
                         (int) sizeof(DEFGENERIC),(VOID *) defgenericArray);
   defgenericArray[obji].busy = 0;
#if DEBUGGING_FUNCTIONS
   defgenericArray[obji].trace = WatchGenerics;
#endif
   defgenericArray[obji].methods = MethodPointer(bgp->methods);
   defgenericArray[obji].mcnt = bgp->mcnt;
   defgenericArray[obji].new_index = 0;
  }

static VOID UpdateMethod(buf,obji)
  VOID *buf;
  long obji;
  {
   BSAVE_METHOD *bmth;
   
   bmth = (BSAVE_METHOD *) buf;
   methodArray[obji].index = bmth->index;
   methodArray[obji].busy = 0;
#if DEBUGGING_FUNCTIONS
   methodArray[obji].trace = WatchMethods;
#endif
   methodArray[obji].restrictionCount = bmth->restrictionCount;
   methodArray[obji].minRestrictions = bmth->minRestrictions;
   methodArray[obji].maxRestrictions = bmth->maxRestrictions;
   methodArray[obji].localVarCount = bmth->localVarCount;
   methodArray[obji].system = bmth->system;
   methodArray[obji].restrictions = RestrictionPointer(bmth->restrictions);
   methodArray[obji].actions = ExpressionPointer(bmth->actions);
   methodArray[obji].ppForm = NULL;
  }

static VOID UpdateRestriction(buf,obji)
  VOID *buf;
  long obji;
  {
   BSAVE_RESTRICTION *brp;
   
   brp = (BSAVE_RESTRICTION *) buf;
   restrictionArray[obji].tcnt = brp->tcnt;
   restrictionArray[obji].types = TypePointer(brp->types);
   restrictionArray[obji].query = ExpressionPointer(brp->query);
  }

static VOID UpdateType(buf,obji)
  VOID *buf;
  long obji;
  {
#if OBJECT_SYSTEM
   typeArray[obji] = (VOID *) DefclassPointer(* (long *) buf);
#else
   if ((* (long *) buf) > (long) INSTANCE_TYPE_CODE)
     {
      PrintWarningID("GENRCBIN",1,CLIPS_FALSE);
      PrintCLIPS(WWARNING,"COOL not installed!  User-defined class\n");
      PrintCLIPS(WWARNING,"  in method restriction substituted with OBJECT.\n");
      typeArray[obji] = (VOID *) AddLong((long) OBJECT_TYPE_CODE);
     }
   else
     typeArray[obji] = (VOID *) AddLong(* (long *) buf);
   IncrementIntegerCount((INTEGER_HN *) typeArray[obji]);
#endif
  }

/***************************************************************
  NAME         : ClearBloadGenerics
  DESCRIPTION  : Release all binary-loaded generic function
                   structure arrays
                 Resets generic function list to NULL
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : Memory cleared
  NOTES        : Generic function name symbol counts decremented
 ***************************************************************/
static VOID ClearBloadGenerics()
  {
   register long i;
   unsigned long space;
   
   space = (unsigned long) (sizeof(DEFGENERIC_MODULE) * ModuleCount);
   if (space == 0L)
     return;
   genlongfree((VOID *) ModuleArray,space);
   ModuleArray = NULL;
   ModuleCount = 0L;

   for (i = 0 ; i < GenericCount ; i++)
     UnmarkConstructHeader(&defgenericArray[i].header);
     
   space = (unsigned long) (sizeof(DEFGENERIC) * GenericCount);
   if (space == 0L)
     return;
   genlongfree((VOID *) defgenericArray,space);
   defgenericArray = NULL;
   GenericCount = 0L;
   
   space = (unsigned long) (sizeof(DEFMETHOD) * MethodCount);
   if (space == 0L)
     return;
   genlongfree((VOID *) methodArray,space);
   methodArray = NULL;
   MethodCount = 0L;
   
   space = (unsigned long) (sizeof(RESTRICTION) * RestrictionCount);
   if (space == 0L)
     return;
   genlongfree((VOID *) restrictionArray,space);
   restrictionArray = NULL;
   RestrictionCount = 0L;

#if ! OBJECT_SYSTEM
   for (i = 0 ; i < TypeCount ; i++)
     DecrementIntegerCount((INTEGER_HN *) typeArray[i]);
#endif
   space = (unsigned long) (sizeof(VOID *) * TypeCount);
   if (space == 0L)
     return;
   genlongfree((VOID *) typeArray,space);
   typeArray = NULL;
   TypeCount = 0L;
  }

#endif

/***************************************************
  NAME         : 
  DESCRIPTION  : 
  INPUTS       : 
  RETURNS      : 
  SIDE EFFECTS : 
  NOTES        : 
 ***************************************************/