/***************************************************
NAME : DeleteMethodInfo
DESCRIPTION : Deallocates all the data associated
w/ a method but does not release
the method structure itself
INPUTS : 1) The generic function address
2) The method address
RETURNS : Nothing useful
SIDE EFFECTS : Nodes deallocated
NOTES : None
***************************************************/
globle void DeleteMethodInfo(
void *theEnv,
DEFGENERIC *gfunc,
DEFMETHOD *meth)
{
short j,k;
RESTRICTION *rptr;
SaveBusyCount(gfunc);
ExpressionDeinstall(theEnv,meth->actions);
ReturnPackedExpression(theEnv,meth->actions);
ClearUserDataList(theEnv,meth->usrData);
if (meth->ppForm != NULL)
rm(theEnv,(void *) meth->ppForm,(sizeof(char) * (strlen(meth->ppForm)+1)));
for (j = 0 ; j < meth->restrictionCount ; j++)
{
rptr = &meth->restrictions[j];
for (k = 0 ; k < rptr->tcnt ; k++)
#if OBJECT_SYSTEM
DecrementDefclassBusyCount(theEnv,rptr->types[k]);
#else
DecrementIntegerCount(theEnv,(INTEGER_HN *) rptr->types[k]);
#endif
if (rptr->types != NULL)
rm(theEnv,(void *) rptr->types,(sizeof(void *) * rptr->tcnt));
ExpressionDeinstall(theEnv,rptr->query);
ReturnPackedExpression(theEnv,rptr->query);
}
if (meth->restrictions != NULL)
rm(theEnv,(void *) meth->restrictions,
(sizeof(RESTRICTION) * meth->restrictionCount));
RestoreBusyCount(gfunc);
}
/***************************************************************
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(
void *theEnv)
{
register long i;
size_t space;
space = (sizeof(DEFGENERIC_MODULE) * DefgenericBinaryData(theEnv)->ModuleCount);
if (space == 0L)
return;
genfree(theEnv,(void *) DefgenericBinaryData(theEnv)->ModuleArray,space);
DefgenericBinaryData(theEnv)->ModuleArray = NULL;
DefgenericBinaryData(theEnv)->ModuleCount = 0L;
for (i = 0 ; i < DefgenericBinaryData(theEnv)->GenericCount ; i++)
UnmarkConstructHeader(theEnv,&DefgenericBinaryData(theEnv)->DefgenericArray[i].header);
space = (sizeof(DEFGENERIC) * DefgenericBinaryData(theEnv)->GenericCount);
if (space == 0L)
return;
genfree(theEnv,(void *) DefgenericBinaryData(theEnv)->DefgenericArray,space);
DefgenericBinaryData(theEnv)->DefgenericArray = NULL;
DefgenericBinaryData(theEnv)->GenericCount = 0L;
space = (sizeof(DEFMETHOD) * DefgenericBinaryData(theEnv)->MethodCount);
if (space == 0L)
return;
genfree(theEnv,(void *) DefgenericBinaryData(theEnv)->MethodArray,space);
DefgenericBinaryData(theEnv)->MethodArray = NULL;
DefgenericBinaryData(theEnv)->MethodCount = 0L;
space = (sizeof(RESTRICTION) * DefgenericBinaryData(theEnv)->RestrictionCount);
if (space == 0L)
return;
genfree(theEnv,(void *) DefgenericBinaryData(theEnv)->RestrictionArray,space);
DefgenericBinaryData(theEnv)->RestrictionArray = NULL;
DefgenericBinaryData(theEnv)->RestrictionCount = 0L;
#if ! OBJECT_SYSTEM
for (i = 0 ; i < DefgenericBinaryData(theEnv)->TypeCount ; i++)
DecrementIntegerCount(theEnv,(INTEGER_HN *) DefgenericBinaryData(theEnv)->TypeArray[i]);
#endif
space = (sizeof(void *) * DefgenericBinaryData(theEnv)->TypeCount);
if (space == 0L)
return;
genfree(theEnv,(void *) DefgenericBinaryData(theEnv)->TypeArray,space);
DefgenericBinaryData(theEnv)->TypeArray = NULL;
DefgenericBinaryData(theEnv)->TypeCount = 0L;
}
/***************************************************************
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;
}
globle void AtomDeinstall(
int type,
void *vPtr)
{
switch (type)
{
case SYMBOL:
case STRING:
#if DEFGLOBAL_CONSTRUCT
case GBL_VARIABLE:
#endif
#if OBJECT_SYSTEM
case INSTANCE_NAME:
#endif
DecrementSymbolCount((SYMBOL_HN *) vPtr);
break;
case FLOAT:
DecrementFloatCount((FLOAT_HN *) vPtr);
break;
case INTEGER:
DecrementIntegerCount((INTEGER_HN *) vPtr);
break;
#if FUZZY_DEFTEMPLATES
case FUZZY_VALUE:
DeinstallFuzzyValue(vPtr);
break;
#endif
case MULTIFIELD:
MultifieldDeinstall((struct multifield *) vPtr);
break;
case RVOID:
break;
default:
if (PrimitivesArray[type] == NULL) break;
if (PrimitivesArray[type]->bitMap) DecrementBitMapCount((BITMAP_HN *) vPtr);
else if (PrimitivesArray[type]->decrementBusyCount)
{ (*PrimitivesArray[type]->decrementBusyCount)(vPtr); }
}
}
globle void AtomDeinstall(
void *theEnv,
int type,
void *vPtr)
{
switch (type)
{
case SYMBOL:
case STRING:
#if DEFGLOBAL_CONSTRUCT
case GBL_VARIABLE:
#endif
#if OBJECT_SYSTEM
case INSTANCE_NAME:
#endif
DecrementSymbolCount(theEnv,(SYMBOL_HN *) vPtr);
break;
case FLOAT:
DecrementFloatCount(theEnv,(FLOAT_HN *) vPtr);
break;
case INTEGER:
DecrementIntegerCount(theEnv,(INTEGER_HN *) vPtr);
break;
case EXTERNAL_ADDRESS:
DecrementExternalAddressCount(theEnv,(EXTERNAL_ADDRESS_HN *) vPtr);
break;
case MULTIFIELD:
MultifieldDeinstall(theEnv,(struct multifield *) vPtr);
break;
case RVOID:
break;
default:
if (EvaluationData(theEnv)->PrimitivesArray[type] == NULL) break;
if (EvaluationData(theEnv)->PrimitivesArray[type]->bitMap) DecrementBitMapCount(theEnv,(BITMAP_HN *) vPtr);
else if (EvaluationData(theEnv)->PrimitivesArray[type]->decrementBusyCount)
{ (*EvaluationData(theEnv)->PrimitivesArray[type]->decrementBusyCount)(theEnv,vPtr); }
}
}