/****************************************************************
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()
{
register DEFGENERIC *gfunc,*gtmp;
int success = TRUE;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded() == TRUE) return(FALSE);
#endif
gfunc = (DEFGENERIC *) GetNextDefgeneric(NULL);
while (gfunc != NULL)
{
gtmp = gfunc;
gfunc = (DEFGENERIC *) GetNextDefgeneric((void *) gfunc);
if (RemoveAllExplicitMethods(gtmp) == FALSE)
{
CantDeleteItemErrorMessage("generic function",GetDefgenericName(gtmp));
success = FALSE;
}
else
{
RemoveConstructFromModule((struct constructHeader *) gtmp);
RemoveDefgeneric((void *) gtmp);
}
}
return(success);
}
/************************************************************
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 : DefgenericsToCode
DESCRIPTION : Writes out static array code for
generic functions, methods, etc.
INPUTS : 1) The base name of the construct set
2) The base id for this construct
3) The file pointer for the header file
4) The base id for the construct set
5) The max number of indices allowed
in an array
RETURNS : -1 if no generic functions, 0 on errors,
1 if generic functions written
SIDE EFFECTS : Code written to files
NOTES : None
*******************************************************/
static int DefgenericsToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
DEFGENERIC *theDefgeneric;
DEFMETHOD *theMethod;
RESTRICTION *theRestriction;
register unsigned i,j,k;
int moduleCount = 0;
int itemArrayCounts[SAVE_ITEMS];
int itemArrayVersions[SAVE_ITEMS];
FILE *itemFiles[SAVE_ITEMS];
int itemReopenFlags[SAVE_ITEMS];
struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS];
for (i = 0 ; i < SAVE_ITEMS ; i++)
{
itemArrayCounts[i] = 0;
itemArrayVersions[i] = 1;
itemFiles[i] = NULL;
itemReopenFlags[i] = FALSE;
itemCodeFiles[i].filePrefix = NULL;
}
/* ===========================================
Include the appropriate generic header file
=========================================== */
fprintf(headerFP,"#include \"genrcfun.h\"\n");
/* =============================================================
Loop through all the modules and all the defgenerics writing
their C code representation to the file as they are traversed
============================================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((void *) theModule);
itemFiles[MODULEI] =
OpenFileIfNeeded(itemFiles[MODULEI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[MODULEI],headerFP,
"DEFGENERIC_MODULE",ModulePrefix(DefgenericCodeItem),
itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
if (itemFiles[MODULEI] == NULL)
goto GenericCodeError;
DefgenericModuleToCode(itemFiles[MODULEI],theModule,imageID,maxIndices);
itemFiles[MODULEI] =
CloseFileIfNeeded(itemFiles[MODULEI],&itemArrayCounts[MODULEI],
&itemArrayVersions[MODULEI],maxIndices,
&itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
theDefgeneric = (DEFGENERIC *) GetNextDefgeneric(NULL);
while (theDefgeneric != NULL)
{
itemFiles[GENERICI] =
OpenFileIfNeeded(itemFiles[GENERICI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[GENERICI],headerFP,
"DEFGENERIC",ConstructPrefix(DefgenericCodeItem),
itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
if (itemFiles[GENERICI] == NULL)
goto GenericCodeError;
SingleDefgenericToCode(itemFiles[GENERICI],imageID,maxIndices,theDefgeneric,
moduleCount,itemArrayVersions[METHODI],
itemArrayCounts[METHODI]);
itemArrayCounts[GENERICI]++;
itemFiles[GENERICI] =
CloseFileIfNeeded(itemFiles[GENERICI],&itemArrayCounts[GENERICI],
&itemArrayVersions[GENERICI],maxIndices,
&itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
if (theDefgeneric->mcnt > 0)
{
/* ===========================================
Make sure that all methods for a particular
generic function go into the same array
=========================================== */
itemFiles[METHODI] =
OpenFileIfNeeded(itemFiles[METHODI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[METHODI],headerFP,
"DEFMETHOD",MethodPrefix(),
itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
if (itemFiles[METHODI] == NULL)
goto GenericCodeError;
for (i = 0 ; i < theDefgeneric->mcnt ; i++)
{
theMethod = &theDefgeneric->methods[i];
if (i > 0)
fprintf(itemFiles[METHODI],",\n");
MethodToCode(itemFiles[METHODI],imageID,theMethod,
itemArrayVersions[RESTRICTIONI],itemArrayCounts[RESTRICTIONI]);
if (theMethod->restrictionCount > 0)
{
/* ========================================
Make sure that all restrictions for a
particular method go into the same array
======================================== */
itemFiles[RESTRICTIONI] =
OpenFileIfNeeded(itemFiles[RESTRICTIONI],fileName,fileID,
imageID,&fileCount,
itemArrayVersions[RESTRICTIONI],headerFP,
"RESTRICTION",RestrictionPrefix(),
itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
if (itemFiles[RESTRICTIONI] == NULL)
goto GenericCodeError;
for (j = 0 ; j < theMethod->restrictionCount ; j++)
{
theRestriction = &theMethod->restrictions[j];
if (j > 0)
fprintf(itemFiles[RESTRICTIONI],",\n");
RestrictionToCode(itemFiles[RESTRICTIONI],imageID,theRestriction,
itemArrayVersions[TYPEI],itemArrayCounts[TYPEI]);
if (theRestriction->tcnt > 0)
{
/* =========================================
Make sure that all types for a particular
restriction go into the same array
========================================= */
itemFiles[TYPEI] =
OpenFileIfNeeded(itemFiles[TYPEI],fileName,fileID,
imageID,&fileCount,
itemArrayVersions[TYPEI],headerFP,
"void *",TypePrefix(),
itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
if (itemFiles[TYPEI] == NULL)
goto GenericCodeError;
for (k = 0 ; k < theRestriction->tcnt ; k++)
{
if (k > 0)
fprintf(itemFiles[TYPEI],",\n");
TypeToCode(itemFiles[TYPEI],imageID,
theRestriction->types[k],maxIndices);
}
itemArrayCounts[TYPEI] += theRestriction->tcnt;
itemFiles[TYPEI] =
CloseFileIfNeeded(itemFiles[TYPEI],&itemArrayCounts[TYPEI],
&itemArrayVersions[TYPEI],maxIndices,
&itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
}
}
itemArrayCounts[RESTRICTIONI] += theMethod->restrictionCount;
itemFiles[RESTRICTIONI] =
CloseFileIfNeeded(itemFiles[RESTRICTIONI],&itemArrayCounts[RESTRICTIONI],
&itemArrayVersions[RESTRICTIONI],maxIndices,
&itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
}
}
itemArrayCounts[METHODI] += theDefgeneric->mcnt;
itemFiles[METHODI] =
CloseFileIfNeeded(itemFiles[METHODI],&itemArrayCounts[METHODI],
&itemArrayVersions[METHODI],maxIndices,
&itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
}
theDefgeneric = (DEFGENERIC *) GetNextDefgeneric(theDefgeneric);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
moduleCount++;
itemArrayCounts[MODULEI]++;
}
CloseDefgenericFiles(itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
return(1);
GenericCodeError:
CloseDefgenericFiles(itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
return(0);
}
static void OutputConstructsCodeInfo(
Environment *theEnv)
{
#if (! DEFFUNCTION_CONSTRUCT) && (! DEFGENERIC_CONSTRUCT) && (! OBJECT_SYSTEM) && (! DEFRULE_CONSTRUCT)
#pragma unused(theEnv)
#endif
#if DEFFUNCTION_CONSTRUCT
Deffunction *theDeffunction;
#endif
#if DEFRULE_CONSTRUCT
Defrule *theDefrule;
#endif
#if DEFGENERIC_CONSTRUCT
Defgeneric *theDefgeneric;
Defmethod *theMethod;
unsigned short methodIndex;
StringBuilder *theSB;
#endif
#if OBJECT_SYSTEM
Defclass *theDefclass;
DefmessageHandler *theHandler;
unsigned handlerIndex;
#endif
#if DEFGENERIC_CONSTRUCT || OBJECT_SYSTEM
const char *prefix, *prefixBefore, *prefixAfter;
#endif
const char *banner;
banner = "\n*** Deffunctions ***\n\n";
#if DEFFUNCTION_CONSTRUCT
for (theDeffunction = GetNextDeffunction(theEnv,NULL);
theDeffunction != NULL;
theDeffunction = GetNextDeffunction(theEnv,theDeffunction))
{
OutputProfileInfo(theEnv,DeffunctionName(theDeffunction),
(struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDeffunction->header.usrData),
NULL,NULL,NULL,&banner);
}
#endif
banner = "\n*** Defgenerics ***\n";
#if DEFGENERIC_CONSTRUCT
theSB = CreateStringBuilder(theEnv,512);
for (theDefgeneric = GetNextDefgeneric(theEnv,NULL);
theDefgeneric != NULL;
theDefgeneric = GetNextDefgeneric(theEnv,theDefgeneric))
{
prefixBefore = "\n";
prefix = DefgenericName(theDefgeneric);
prefixAfter = "\n";
for (methodIndex = GetNextDefmethod(theDefgeneric,0);
methodIndex != 0;
methodIndex = GetNextDefmethod(theDefgeneric,methodIndex))
{
theMethod = GetDefmethodPointer(theDefgeneric,methodIndex);
DefmethodDescription(theDefgeneric,methodIndex,theSB);
if (OutputProfileInfo(theEnv,theSB->contents,
(struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theMethod->header.usrData),
prefixBefore,prefix,prefixAfter,&banner))
{
prefixBefore = NULL;
prefix = NULL;
prefixAfter = NULL;
}
}
}
SBDispose(theSB);
#endif
banner = "\n*** Defclasses ***\n";
#if OBJECT_SYSTEM
for (theDefclass = GetNextDefclass(theEnv,NULL);
theDefclass != NULL;
theDefclass = GetNextDefclass(theEnv,theDefclass))
{
prefixAfter = "\n";
prefix = DefclassName(theDefclass);
prefixBefore = "\n";
for (handlerIndex = GetNextDefmessageHandler(theDefclass,0);
handlerIndex != 0;
handlerIndex = GetNextDefmessageHandler(theDefclass,handlerIndex))
{
theHandler = GetDefmessageHandlerPointer(theDefclass,handlerIndex);
if (OutputProfileInfo(theEnv,DefmessageHandlerName(theDefclass,handlerIndex),
(struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,
theHandler->header.usrData),
prefixBefore,prefix,prefixAfter,&banner))
{
prefixBefore = NULL;
prefix = NULL;
prefixAfter = NULL;
}
}
}
#endif
banner = "\n*** Defrules ***\n\n";
#if DEFRULE_CONSTRUCT
for (theDefrule = GetNextDefrule(theEnv,NULL);
theDefrule != NULL;
theDefrule = GetNextDefrule(theEnv,theDefrule))
{
OutputProfileInfo(theEnv,DefruleName(theDefrule),
(struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDefrule->header.usrData),
NULL,NULL,NULL,&banner);
}
#endif
}
void ProfileResetCommand(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
struct functionDefinition *theFunction;
int i;
#if DEFFUNCTION_CONSTRUCT
Deffunction *theDeffunction;
#endif
#if DEFRULE_CONSTRUCT
Defrule *theDefrule;
#endif
#if DEFGENERIC_CONSTRUCT
Defgeneric *theDefgeneric;
unsigned short methodIndex;
Defmethod *theMethod;
#endif
#if OBJECT_SYSTEM
Defclass *theDefclass;
DefmessageHandler *theHandler;
unsigned handlerIndex;
#endif
ProfileFunctionData(theEnv)->ProfileStartTime = 0.0;
ProfileFunctionData(theEnv)->ProfileEndTime = 0.0;
ProfileFunctionData(theEnv)->ProfileTotalTime = 0.0;
ProfileFunctionData(theEnv)->LastProfileInfo = NO_PROFILE;
for (theFunction = GetFunctionList(theEnv);
theFunction != NULL;
theFunction = theFunction->next)
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theFunction->usrData));
}
for (i = 0; i < MAXIMUM_PRIMITIVES; i++)
{
if (EvaluationData(theEnv)->PrimitivesArray[i] != NULL)
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,EvaluationData(theEnv)->PrimitivesArray[i]->usrData));
}
}
#if DEFFUNCTION_CONSTRUCT
for (theDeffunction = GetNextDeffunction(theEnv,NULL);
theDeffunction != NULL;
theDeffunction = GetNextDeffunction(theEnv,theDeffunction))
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDeffunction->header.usrData));
}
#endif
#if DEFRULE_CONSTRUCT
for (theDefrule = GetNextDefrule(theEnv,NULL);
theDefrule != NULL;
theDefrule = GetNextDefrule(theEnv,theDefrule))
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDefrule->header.usrData));
}
#endif
#if DEFGENERIC_CONSTRUCT
for (theDefgeneric = GetNextDefgeneric(theEnv,NULL);
theDefgeneric != NULL;
theDefgeneric = GetNextDefgeneric(theEnv,theDefgeneric))
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDefgeneric->header.usrData));
for (methodIndex = GetNextDefmethod(theDefgeneric,0);
methodIndex != 0;
methodIndex = GetNextDefmethod(theDefgeneric,methodIndex))
{
theMethod = GetDefmethodPointer(theDefgeneric,methodIndex);
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theMethod->header.usrData));
}
}
#endif
#if OBJECT_SYSTEM
for (theDefclass = GetNextDefclass(theEnv,NULL);
theDefclass != NULL;
theDefclass = GetNextDefclass(theEnv,theDefclass))
{
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theDefclass->header.usrData));
for (handlerIndex = GetNextDefmessageHandler(theDefclass,0);
handlerIndex != 0;
handlerIndex = GetNextDefmessageHandler(theDefclass,handlerIndex))
{
theHandler = GetDefmessageHandlerPointer(theDefclass,handlerIndex);
ResetProfileInfo((struct constructProfileInfo *)
TestUserData(ProfileFunctionData(theEnv)->ProfileDataID,theHandler->header.usrData));
}
}
#endif
}