/*********************************************************************** NAME : BloadStorageDefinstances DESCRIPTION : This routine space required for definstances 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 BloadStorageDefinstances( void *theEnv) { unsigned long space; GenReadBinary(theEnv,(void *) &space,(unsigned long) sizeof(unsigned long)); if (space == 0L) return; GenReadBinary(theEnv,(void *) &DefinstancesBinaryData(theEnv)->ModuleCount,(unsigned long) sizeof(unsigned long)); GenReadBinary(theEnv,(void *) &DefinstancesBinaryData(theEnv)->DefinstancesCount,(unsigned long) sizeof(unsigned long)); if (DefinstancesBinaryData(theEnv)->ModuleCount == 0L) { DefinstancesBinaryData(theEnv)->ModuleArray = NULL; DefinstancesBinaryData(theEnv)->DefinstancesArray = NULL; return; } space = (unsigned long) (DefinstancesBinaryData(theEnv)->ModuleCount * sizeof(DEFINSTANCES_MODULE)); DefinstancesBinaryData(theEnv)->ModuleArray = (DEFINSTANCES_MODULE *) genlongalloc(theEnv,space); if (DefinstancesBinaryData(theEnv)->DefinstancesCount == 0L) { DefinstancesBinaryData(theEnv)->DefinstancesArray = NULL; return; } space = (unsigned long) (DefinstancesBinaryData(theEnv)->DefinstancesCount * sizeof(DEFINSTANCES)); DefinstancesBinaryData(theEnv)->DefinstancesArray = (DEFINSTANCES *) genlongalloc(theEnv,space); }
/*********************************************************************** NAME : BloadStorageDeffunctions DESCRIPTION : This routine space required for deffunction 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 BloadStorageDeffunctions( void *theEnv) { unsigned long space; GenReadBinary(theEnv,(void *) &space,(unsigned long) sizeof(unsigned long)); if (space == 0L) return; GenReadBinary(theEnv,(void *) &DeffunctionBinaryData(theEnv)->ModuleCount,(unsigned long) sizeof(unsigned long)); GenReadBinary(theEnv,(void *) &DeffunctionBinaryData(theEnv)->DeffunctionCount,(unsigned long) sizeof(unsigned long)); if (DeffunctionBinaryData(theEnv)->ModuleCount == 0L) { DeffunctionBinaryData(theEnv)->ModuleArray = NULL; DeffunctionBinaryData(theEnv)->DeffunctionArray = NULL; return; } space = (unsigned long) (DeffunctionBinaryData(theEnv)->ModuleCount * sizeof(DEFFUNCTION_MODULE)); DeffunctionBinaryData(theEnv)->ModuleArray = (DEFFUNCTION_MODULE *) genlongalloc(theEnv,space); if (DeffunctionBinaryData(theEnv)->DeffunctionCount == 0L) { DeffunctionBinaryData(theEnv)->DeffunctionArray = NULL; return; } space = (unsigned long) (DeffunctionBinaryData(theEnv)->DeffunctionCount * sizeof(DEFFUNCTION)); DeffunctionBinaryData(theEnv)->DeffunctionArray = (DEFFUNCTION *) genlongalloc(theEnv,space); }
/*********************************************************************** NAME : BloadStorageDeffunctions DESCRIPTION : This routine space required for deffunction 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 BloadStorageDeffunctions() { unsigned long space; GenRead((void *) &space,(unsigned long) sizeof(unsigned long)); if (space == 0L) return; GenRead((void *) &ModuleCount,(unsigned long) sizeof(unsigned long)); GenRead((void *) &DeffunctionCount,(unsigned long) sizeof(unsigned long)); if (ModuleCount == 0L) { ModuleArray = NULL; deffunctionArray = NULL; return; } space = (unsigned long) (ModuleCount * sizeof(DEFFUNCTION_MODULE)); ModuleArray = (DEFFUNCTION_MODULE *) genlongalloc(space); if (DeffunctionCount == 0L) { deffunctionArray = NULL; return; } space = (unsigned long) (DeffunctionCount * sizeof(DEFFUNCTION)); deffunctionArray = (DEFFUNCTION *) genlongalloc(space); }
static void BloadStorage( void *theEnv) { unsigned long int space; /*=========================================================*/ /* Determine the number of deftemplate, deftemplateModule, */ /* and templateSlot data structures to be read. */ /*=========================================================*/ GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int)); GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfDeftemplates,(unsigned long) sizeof(long int)); GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots,(unsigned long) sizeof(long int)); GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateModules,(unsigned long) sizeof(long int)); /*====================================*/ /* Allocate the space needed for the */ /* deftemplateModule data structures. */ /*====================================*/ if (DeftemplateBinaryData(theEnv)->NumberOfTemplateModules == 0) { DeftemplateBinaryData(theEnv)->DeftemplateArray = NULL; DeftemplateBinaryData(theEnv)->SlotArray = NULL; DeftemplateBinaryData(theEnv)->ModuleArray = NULL; return; } space = DeftemplateBinaryData(theEnv)->NumberOfTemplateModules * sizeof(struct deftemplateModule); DeftemplateBinaryData(theEnv)->ModuleArray = (struct deftemplateModule *) genlongalloc(theEnv,space); /*===================================*/ /* Allocate the space needed for the */ /* deftemplate data structures. */ /*===================================*/ if (DeftemplateBinaryData(theEnv)->NumberOfDeftemplates == 0) { DeftemplateBinaryData(theEnv)->DeftemplateArray = NULL; DeftemplateBinaryData(theEnv)->SlotArray = NULL; return; } space = DeftemplateBinaryData(theEnv)->NumberOfDeftemplates * sizeof(struct deftemplate); DeftemplateBinaryData(theEnv)->DeftemplateArray = (struct deftemplate *) genlongalloc(theEnv,space); /*===================================*/ /* Allocate the space needed for the */ /* templateSlot data structures. */ /*===================================*/ if (DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots == 0) { DeftemplateBinaryData(theEnv)->SlotArray = NULL; return; } space = DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots * sizeof(struct templateSlot); DeftemplateBinaryData(theEnv)->SlotArray = (struct templateSlot *) genlongalloc(theEnv,space); }
/*************************************************** NAME : BloadStorageObjectPatterns DESCRIPTION : Reads in the storage requirements for the object patterns in this bload image INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : Counts read and arrays allocated NOTES : None ***************************************************/ static void BloadStorageObjectPatterns( void *theEnv) { UNLN space; long counts[2]; GenReadBinary(theEnv,(void *) &space,(UNLN) sizeof(UNLN)); GenReadBinary(theEnv,(void *) counts,space); ObjectReteBinaryData(theEnv)->AlphaNodeCount = counts[0]; ObjectReteBinaryData(theEnv)->PatternNodeCount = counts[1]; if (ObjectReteBinaryData(theEnv)->AlphaNodeCount == 0L) ObjectReteBinaryData(theEnv)->AlphaArray = NULL; else { space = (UNLN) (ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE)); ObjectReteBinaryData(theEnv)->AlphaArray = (OBJECT_ALPHA_NODE *) genlongalloc(theEnv,space); } if (ObjectReteBinaryData(theEnv)->PatternNodeCount == 0L) ObjectReteBinaryData(theEnv)->PatternArray = NULL; else { space = (UNLN) (ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(OBJECT_PATTERN_NODE)); ObjectReteBinaryData(theEnv)->PatternArray = (OBJECT_PATTERN_NODE *) genlongalloc(theEnv,space); } }
/*************************************************** NAME : BloadStorageObjectPatterns DESCRIPTION : Reads in the storage requirements for the object patterns in this bload image INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : Counts read and arrays allocated NOTES : None ***************************************************/ static void BloadStorageObjectPatterns() { UNLN space; long counts[2]; GenRead((void *) &space,(UNLN) sizeof(UNLN)); GenRead((void *) counts,space); AlphaNodeCount = counts[0]; PatternNodeCount = counts[1]; if (AlphaNodeCount == 0L) AlphaArray = NULL; else { space = (UNLN) (AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE)); AlphaArray = (OBJECT_ALPHA_NODE *) genlongalloc(space); } if (PatternNodeCount == 0L) PatternArray = NULL; else { space = (UNLN) (PatternNodeCount * sizeof(OBJECT_PATTERN_NODE)); PatternArray = (OBJECT_PATTERN_NODE *) genlongalloc(space); } }
static void BloadStorage( void *theEnv) { unsigned long space; /*=================================================*/ /* Determine the number of defrule, defruleModule, */ /* and joinNode data structures to be read. */ /*=================================================*/ GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int)); GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefruleModules,(unsigned long) sizeof(long int)); GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefrules,(unsigned long) sizeof(long int)); GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfJoins,(unsigned long) sizeof(long int)); /*===================================*/ /* Allocate the space needed for the */ /* defruleModule data structures. */ /*===================================*/ if (DefruleBinaryData(theEnv)->NumberOfDefruleModules == 0) { DefruleBinaryData(theEnv)->ModuleArray = NULL; DefruleBinaryData(theEnv)->DefruleArray = NULL; DefruleBinaryData(theEnv)->JoinArray = NULL; } space = DefruleBinaryData(theEnv)->NumberOfDefruleModules * sizeof(struct defruleModule); DefruleBinaryData(theEnv)->ModuleArray = (struct defruleModule *) genlongalloc(theEnv,space); /*===============================*/ /* Allocate the space needed for */ /* the defrule data structures. */ /*===============================*/ if (DefruleBinaryData(theEnv)->NumberOfDefrules == 0) { DefruleBinaryData(theEnv)->DefruleArray = NULL; DefruleBinaryData(theEnv)->JoinArray = NULL; return; } space = DefruleBinaryData(theEnv)->NumberOfDefrules * sizeof(struct defrule); DefruleBinaryData(theEnv)->DefruleArray = (struct defrule *) genlongalloc(theEnv,space); /*===============================*/ /* Allocate the space needed for */ /* the joinNode data structures. */ /*===============================*/ space = DefruleBinaryData(theEnv)->NumberOfJoins * sizeof(struct joinNode); DefruleBinaryData(theEnv)->JoinArray = (struct joinNode *) genlongalloc(theEnv,space); }
/*********************************************************************** 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( void *theEnv) { unsigned long space; long counts[5]; GenReadBinary(theEnv,(void *) &space,(unsigned long) sizeof(unsigned long)); if (space == 0L) return; GenReadBinary(theEnv,(void *) counts,space); DefgenericBinaryData(theEnv)->ModuleCount = counts[0]; DefgenericBinaryData(theEnv)->GenericCount = counts[1]; DefgenericBinaryData(theEnv)->MethodCount = counts[2]; DefgenericBinaryData(theEnv)->RestrictionCount = counts[3]; DefgenericBinaryData(theEnv)->TypeCount = counts[4]; if (DefgenericBinaryData(theEnv)->ModuleCount != 0L) { space = (unsigned long) (sizeof(DEFGENERIC_MODULE) * DefgenericBinaryData(theEnv)->ModuleCount); DefgenericBinaryData(theEnv)->ModuleArray = (DEFGENERIC_MODULE *) genlongalloc(theEnv,space); } else return; if (DefgenericBinaryData(theEnv)->GenericCount != 0L) { space = (unsigned long) (sizeof(DEFGENERIC) * DefgenericBinaryData(theEnv)->GenericCount); DefgenericBinaryData(theEnv)->DefgenericArray = (DEFGENERIC *) genlongalloc(theEnv,space); } else return; if (DefgenericBinaryData(theEnv)->MethodCount != 0L) { space = (unsigned long) (sizeof(DEFMETHOD) * DefgenericBinaryData(theEnv)->MethodCount); DefgenericBinaryData(theEnv)->MethodArray = (DEFMETHOD *) genlongalloc(theEnv,space); } else return; if (DefgenericBinaryData(theEnv)->RestrictionCount != 0L) { space = (unsigned long) (sizeof(RESTRICTION) * DefgenericBinaryData(theEnv)->RestrictionCount); DefgenericBinaryData(theEnv)->RestrictionArray = (RESTRICTION *) genlongalloc(theEnv,space); } else return; if (DefgenericBinaryData(theEnv)->TypeCount != 0L) { space = (unsigned long) (sizeof(void *) * DefgenericBinaryData(theEnv)->TypeCount); DefgenericBinaryData(theEnv)->TypeArray = (void * *) genlongalloc(theEnv,space); } }
/*********************************************************************** 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 *) genlongalloc(space); } else return; if (GenericCount != 0L) { space = (unsigned long) (sizeof(DEFGENERIC) * GenericCount); defgenericArray = (DEFGENERIC *) genlongalloc(space); } else return; if (MethodCount != 0L) { space = (unsigned long) (sizeof(DEFMETHOD) * MethodCount); methodArray = (DEFMETHOD *) genlongalloc(space); } else return; if (RestrictionCount != 0L) { space = (unsigned long) (sizeof(RESTRICTION) * RestrictionCount); restrictionArray = (RESTRICTION *) genlongalloc(space); } else return; if (TypeCount != 0L) { space = (unsigned long) (sizeof(void *) * TypeCount); typeArray = (void * *) genlongalloc(space); } }
static void BloadStorage( void *theEnv) { unsigned long int space; /*=======================================*/ /* Determine the number of defmodule and */ /* port item data structures to be read. */ /*=======================================*/ GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int)); GenReadBinary(theEnv,&DefmoduleData(theEnv)->BNumberOfDefmodules,(unsigned long) sizeof(long int)); GenReadBinary(theEnv,&DefmoduleData(theEnv)->NumberOfPortItems,(unsigned long) sizeof(long int)); /*================================*/ /* Allocate the space needed for */ /* the defmodule data structures. */ /*================================*/ if (DefmoduleData(theEnv)->BNumberOfDefmodules == 0) { DefmoduleData(theEnv)->DefmoduleArray = NULL; return; } space = (unsigned long) (DefmoduleData(theEnv)->BNumberOfDefmodules * sizeof(struct defmodule)); DefmoduleData(theEnv)->DefmoduleArray = (struct defmodule *) genlongalloc(theEnv,space); /*================================*/ /* Allocate the space needed for */ /* the port item data structures. */ /*================================*/ if (DefmoduleData(theEnv)->NumberOfPortItems == 0) { DefmoduleData(theEnv)->PortItemArray = NULL; return; } space = (unsigned long) (DefmoduleData(theEnv)->NumberOfPortItems * sizeof(struct portItem)); DefmoduleData(theEnv)->PortItemArray = (struct portItem *) genlongalloc(theEnv,space); }
static void BloadStorageDefglobals() { unsigned long int space; /*=======================================================*/ /* Determine the number of defglobal and defglobalModule */ /* data structures to be read. */ /*=======================================================*/ GenRead(&space,(unsigned long) sizeof(unsigned long int)); GenRead(&NumberOfDefglobals,(unsigned long) sizeof(long int)); GenRead(&NumberOfDefglobalModules,(unsigned long) sizeof(long int)); /*===================================*/ /* Allocate the space needed for the */ /* defglobalModule data structures. */ /*===================================*/ if (NumberOfDefglobalModules == 0) { DefglobalArray = NULL; ModuleArray = NULL; } space = NumberOfDefglobalModules * sizeof(struct defglobalModule); ModuleArray = (struct defglobalModule *) genlongalloc(space); /*===================================*/ /* Allocate the space needed for the */ /* defglobal data structures. */ /*===================================*/ if (NumberOfDefglobals == 0) { DefglobalArray = NULL; return; } space = (unsigned long) (NumberOfDefglobals * sizeof(struct defglobal)); DefglobalArray = (struct defglobal *) genlongalloc(space); }
globle void ReadNeededConstraints( void *theEnv) { GenReadBinary(theEnv,(void *) &ConstraintData(theEnv)->NumberOfConstraints,(unsigned long) sizeof(unsigned long int)); if (ConstraintData(theEnv)->NumberOfConstraints == 0) return; ConstraintData(theEnv)->ConstraintArray = (CONSTRAINT_RECORD *) genlongalloc(theEnv,(unsigned long) (sizeof(CONSTRAINT_RECORD) * ConstraintData(theEnv)->NumberOfConstraints)); BloadandRefresh(theEnv,ConstraintData(theEnv)->NumberOfConstraints,sizeof(BSAVE_CONSTRAINT_RECORD), CopyFromBsaveConstraintRecord); }
/************************************************************ NAME : BloadandRefresh DESCRIPTION : Loads and refreshes objects - will bload all objects at once, if possible, but will aslo work in increments if memory is restricted INPUTS : 1) the number of objects to bload and update 2) the size of one object 3) An update function which takes a bloaded object buffer and the index of the object to refresh as arguments RETURNS : Nothing useful SIDE EFFECTS : Objects bloaded and updated NOTES : Assumes binary file pointer is positioned for bloads of the objects ************************************************************/ globle void BloadandRefresh( void *theEnv, long objcnt, unsigned objsz, void (*objupdate)(void *,void *,long)) { register long i,bi; char *buf; long objsmaxread,objsread; unsigned long space; int (*oldOutOfMemoryFunction)(void *,unsigned long); if (objcnt == 0L) return; oldOutOfMemoryFunction = EnvSetOutOfMemoryFunction(theEnv,BloadOutOfMemoryFunction); objsmaxread = objcnt; do { space = objsmaxread * objsz; buf = (char *) genlongalloc(theEnv,space); if (buf == NULL) { if ((objsmaxread / 2) == 0) { if ((*oldOutOfMemoryFunction)(theEnv,space) == TRUE) { EnvSetOutOfMemoryFunction(theEnv,oldOutOfMemoryFunction); return; } } else objsmaxread /= 2; } } while (buf == NULL); EnvSetOutOfMemoryFunction(theEnv,oldOutOfMemoryFunction); i = 0L; do { objsread = (objsmaxread > (objcnt - i)) ? (objcnt - i) : objsmaxread; GenReadBinary(theEnv,(void *) buf,objsread * objsz); for (bi = 0L ; bi < objsread ; bi++ , i++) (*objupdate)(theEnv,buf + objsz * bi,i); } while (i < objcnt); genlongfree(theEnv,(void *) buf,space); }
globle int PrintNRouter( void *theEnv, char *logicalName, char *str, unsigned long length) { char *tempStr; int rv; tempStr = (char *) genlongalloc(theEnv,length+1); strncpy(tempStr,str,length); tempStr[length] = 0; rv = EnvPrintRouter(theEnv,logicalName,tempStr); genlongfree(theEnv,tempStr,length+1); return(rv); }
globle void *gm3( void *theEnv, long size) { struct memoryPtr *memPtr; if (size < sizeof(char *)) size = sizeof(char *); if (size >= MEM_TABLE_SIZE) return(genlongalloc(theEnv,(unsigned long) size)); memPtr = (struct memoryPtr *) MemoryData(theEnv)->MemoryTable[(int) size]; if (memPtr == NULL) { return(genalloc(theEnv,(unsigned int) size)); } MemoryData(theEnv)->MemoryTable[(int) size] = memPtr->next; return ((void *) memPtr); }
static void BloadStorage() { unsigned long space; /*=================================================*/ /* Determine the number of defrule, defruleModule, */ /* and joinNode data structures to be read. */ /*=================================================*/ GenRead(&space,(unsigned long) sizeof(unsigned long int)); GenRead(&NumberOfDefruleModules,(unsigned long) sizeof(long int)); GenRead(&NumberOfDefrules,(unsigned long) sizeof(long int)); GenRead(&NumberOfJoins,(unsigned long) sizeof(long int)); #if FUZZY_DEFTEMPLATES GenRead(&NumberOfPatternFuzzyValues,(unsigned long) sizeof(long int)); #endif /*===================================*/ /* Allocate the space needed for the */ /* defruleModule data structures. */ /*===================================*/ if (NumberOfDefruleModules == 0) { ModuleArray = NULL; DefruleArray = NULL; JoinArray = NULL; #if FUZZY_DEFTEMPLATES PatternFuzzyValueArray = NULL; #endif } space = NumberOfDefruleModules * sizeof(struct defruleModule); ModuleArray = (struct defruleModule *) genlongalloc(space); /*===============================*/ /* Allocate the space needed for */ /* the defrule data structures. */ /*===============================*/ if (NumberOfDefrules == 0) { DefruleArray = NULL; JoinArray = NULL; #if FUZZY_DEFTEMPLATES PatternFuzzyValueArray = NULL; #endif return; } space = NumberOfDefrules * sizeof(struct defrule); DefruleArray = (struct defrule *) genlongalloc(space); #if FUZZY_DEFTEMPLATES /*=======================================*/ /* Get Space for the PatternFuzzyValues. */ /*=======================================*/ space = NumberOfPatternFuzzyValues * sizeof(struct fzSlotLocator); if (space > 0) PatternFuzzyValueArray = (struct fzSlotLocator *) genlongalloc(space); else PatternFuzzyValueArray = NULL; #endif /*===============================*/ /* Allocate the space needed for */ /* the joinNode data structures. */ /*===============================*/ space = NumberOfJoins * sizeof(struct joinNode); JoinArray = (struct joinNode *) genlongalloc(space); }
/*********************************************************************** NAME : BloadStorageObjects DESCRIPTION : This routine reads class and handler information from a binary file in five chunks: Class count Handler count Class array Handler array INPUTS : Notthing RETURNS : Nothing useful SIDE EFFECTS : Arrays allocated and set NOTES : This routine makes no attempt to reset any pointers within the structures Bload fails if there are still classes in the system!! ***********************************************************************/ static void BloadStorageObjects() { UNLN space; long counts[9]; if ((ClassIDMap != NULL) || (MaxClassID != 0)) { SystemError("OBJBIN",1); ExitRouter(EXIT_FAILURE); } GenRead((void *) &space,(UNLN) sizeof(UNLN)); if (space == 0L) { ClassCount = HandlerCount = 0L; return; } GenRead((void *) counts,space); ModuleCount = counts[0]; ClassCount = counts[1]; LinkCount = counts[2]; SlotNameCount = counts[3]; SlotCount = counts[4]; TemplateSlotCount = counts[5]; SlotNameMapCount = counts[6]; HandlerCount = counts[7]; MaxClassID = (unsigned short) counts[8]; if (ModuleCount != 0L) { space = (UNLN) (sizeof(DEFCLASS_MODULE) * ModuleCount); ModuleArray = (DEFCLASS_MODULE *) genlongalloc(space); } if (ClassCount != 0L) { space = (UNLN) (sizeof(DEFCLASS) * ClassCount); defclassArray = (DEFCLASS *) genlongalloc(space); ClassIDMap = (DEFCLASS **) gm2((int) (sizeof(DEFCLASS *) * MaxClassID)); } if (LinkCount != 0L) { space = (UNLN) (sizeof(DEFCLASS *) * LinkCount); linkArray = (DEFCLASS * *) genlongalloc(space); } if (SlotCount != 0L) { space = (UNLN) (sizeof(SLOT_DESC) * SlotCount); slotArray = (SLOT_DESC *) genlongalloc(space); } if (SlotNameCount != 0L) { space = (UNLN) (sizeof(SLOT_NAME) * SlotNameCount); slotNameArray = (SLOT_NAME *) genlongalloc(space); } if (TemplateSlotCount != 0L) { space = (UNLN) (sizeof(SLOT_DESC *) * TemplateSlotCount); tmpslotArray = (SLOT_DESC * *) genlongalloc(space); } if (SlotNameMapCount != 0L) { space = (UNLN) (sizeof(unsigned) * SlotNameMapCount); mapslotArray = (unsigned *) genlongalloc(space); } if (HandlerCount != 0L) { space = (UNLN) (sizeof(HANDLER) * HandlerCount); handlerArray = (HANDLER *) genlongalloc(space); space = (UNLN) (sizeof(unsigned) * HandlerCount); maphandlerArray = (unsigned *) genlongalloc(space); } }