void DefruleRunTimeInitialize(
Environment *theEnv,
struct joinLink *rightPrime,
struct joinLink *leftPrime)
{
Defmodule *theModule;
Defrule *theRule, *theDisjunct;
DefruleData(theEnv)->RightPrimeJoins = rightPrime;
DefruleData(theEnv)->LeftPrimeJoins = leftPrime;
SaveCurrentModule(theEnv);
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theRule = GetNextDefrule(theEnv,NULL);
theRule != NULL;
theRule = GetNextDefrule(theEnv,theRule))
{
for (theDisjunct = theRule;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct)
{
theDisjunct->header.env = theEnv;
AddBetaMemoriesToRule(theEnv,theDisjunct->lastJoin);
}
}
}
RestoreCurrentModule(theEnv);
}
static void DeallocateDefglobalData(
Environment *theEnv)
{
#if ! RUN_TIME
struct defglobalModule *theModuleItem;
Defmodule *theModule;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) return;
#endif
DoForAllConstructs(theEnv,DestroyDefglobalAction,
DefglobalData(theEnv)->DefglobalModuleIndex,false,NULL);
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct defglobalModule *)
GetModuleItem(theEnv,theModule,
DefglobalData(theEnv)->DefglobalModuleIndex);
rtn_struct(theEnv,defglobalModule,theModuleItem);
}
#else
DoForAllConstructs(theEnv,DestroyDefglobalAction,DefglobalData(theEnv)->DefglobalModuleIndex,false,NULL);
#endif
}
static void BsaveExpressions(
FILE *fp)
{
struct defrule *theDefrule, *theDisjunct;
struct defmodule *theModule;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*======================================================*/
/* Set the current module to the module being examined. */
/*======================================================*/
SetCurrentModule((void *) theModule);
/*==================================================*/
/* Loop through each defrule in the current module. */
/*==================================================*/
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{
/*===========================================*/
/* Save the dynamic salience of the defrule. */
/*===========================================*/
#if DYNAMIC_SALIENCE
BsaveExpression(theDefrule->dynamicSalience,fp);
#endif
#if CERTAINTY_FACTORS
BsaveExpression(theDefrule->dynamicCF,fp);
#endif
/*===================================*/
/* Loop through each disjunct of the */
/* defrule and save its RHS actions. */
/*===================================*/
for (theDisjunct = theDefrule;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct)
{ BsaveExpression(theDisjunct->actions,fp); }
}
}
/*==============================*/
/* Set the marked flag for each */
/* join in the join network. */
/*==============================*/
MarkRuleNetwork(1);
}
globle void TagRuleNetwork(
long int *moduleCount,
long int *ruleCount,
long int *joinCount)
{
struct defmodule *modulePtr;
struct defrule *rulePtr;
struct joinNode *joinPtr;
*moduleCount = 0;
*ruleCount = 0;
*joinCount = 0;
MarkRuleNetwork(0);
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (modulePtr = (struct defmodule *) GetNextDefmodule(NULL);
modulePtr != NULL;
modulePtr = (struct defmodule *) GetNextDefmodule(modulePtr))
{
(*moduleCount)++;
SetCurrentModule((void *) modulePtr);
/*=========================*/
/* Loop through each rule. */
/*=========================*/
rulePtr = (struct defrule *) GetNextDefrule(NULL);
while (rulePtr != NULL)
{
rulePtr->header.bsaveID = *ruleCount;
(*ruleCount)++;
/*=========================*/
/* Loop through each join. */
/*=========================*/
for (joinPtr = rulePtr->lastJoin;
joinPtr != NULL;
joinPtr = GetPreviousJoin(joinPtr))
{
if (joinPtr->marked == 0)
{
joinPtr->marked = 1;
joinPtr->bsaveID = *joinCount;
(*joinCount)++;
}
}
if (rulePtr->disjunct != NULL) rulePtr = rulePtr->disjunct;
else rulePtr = (struct defrule *) GetNextDefrule(rulePtr);
}
}
}
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 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);
}
globle void MarkRuleNetwork(
int value)
{
struct defrule *rulePtr;
struct joinNode *joinPtr;
struct defmodule *modulePtr;
/*===========================*/
/* Loop through each module. */
/*===========================*/
SaveCurrentModule();
for (modulePtr = (struct defmodule *) GetNextDefmodule(NULL);
modulePtr != NULL;
modulePtr = (struct defmodule *) GetNextDefmodule(modulePtr))
{
SetCurrentModule((void *) modulePtr);
/*=========================*/
/* Loop through each rule. */
/*=========================*/
rulePtr = (struct defrule *) GetNextDefrule(NULL);
while (rulePtr != NULL)
{
/*=============================*/
/* Mark each join for the rule */
/* with the specified value. */
/*=============================*/
joinPtr = rulePtr->lastJoin;
while (joinPtr != NULL)
{
joinPtr->marked = value;
joinPtr = GetPreviousJoin(joinPtr);
}
/*=================================*/
/* Move on to the next rule or the */
/* next disjunct for this rule. */
/*=================================*/
if (rulePtr->disjunct != NULL) rulePtr = rulePtr->disjunct;
else rulePtr = (struct defrule *) GetNextDefrule(rulePtr);
}
}
RestoreCurrentModule();
}
static void BeforePatternNetworkToCode()
{
int whichPattern = 0;
int whichDeftemplate = 0;
struct defmodule *theModule;
struct deftemplate *theDeftemplate;
struct factPatternNode *thePattern;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
SetCurrentModule((void *) theModule);
/*======================================================*/
/* Loop through each deftemplate in the current module. */
/*======================================================*/
for (theDeftemplate = (struct deftemplate *) GetNextDeftemplate(NULL);
theDeftemplate != NULL;
theDeftemplate = (struct deftemplate *) GetNextDeftemplate(theDeftemplate))
{
/*=================================================*/
/* Assign each pattern node in the pattern network */
/* for the deftemplate a unique integer ID. */
/*=================================================*/
theDeftemplate->header.bsaveID = whichDeftemplate++;
for (thePattern = theDeftemplate->patternNetwork;
thePattern != NULL;
thePattern = GetNextPatternNode(thePattern))
{ thePattern->bsaveID = whichPattern++; }
}
}
}
void UpdateDefglobalScope(
Environment *theEnv)
{
Defglobal *theDefglobal;
unsigned int moduleCount;
Defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*============================*/
/* Loop through every module. */
/*============================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*============================================================*/
/* Loop through every defglobal in the module being examined. */
/*============================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DefglobalData(theEnv)->DefglobalModuleIndex);
for (theDefglobal = (Defglobal *) theItem->firstItem;
theDefglobal != NULL ;
theDefglobal = GetNextDefglobal(theEnv,theDefglobal))
{
/*====================================================*/
/* If the defglobal is visible to the current module, */
/* then mark it as being in scope, otherwise mark it */
/* as being out of scope. */
/*====================================================*/
if (FindImportedConstruct(theEnv,"defglobal",theModule,
theDefglobal->header.name->contents,
&moduleCount,true,NULL) != NULL)
{ theDefglobal->inScope = true; }
else
{ theDefglobal->inScope = false; }
}
}
}
static void BsaveJoins(
FILE *fp)
{
struct defrule *rulePtr;
struct joinNode *joinPtr;
struct defmodule *theModule;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
/*===========================================*/
/* Loop through each rule and its disjuncts. */
/*===========================================*/
rulePtr = (struct defrule *) GetNextDefrule(NULL);
while (rulePtr != NULL)
{
/*=========================================*/
/* Loop through each join of the disjunct. */
/*=========================================*/
for (joinPtr = rulePtr->lastJoin;
joinPtr != NULL;
joinPtr = GetPreviousJoin(joinPtr))
{ if (joinPtr->marked) BsaveJoin(fp,joinPtr); }
/*=======================================*/
/* Move on to the next rule or disjunct. */
/*=======================================*/
if (rulePtr->disjunct != NULL) rulePtr = rulePtr->disjunct;
else rulePtr = (struct defrule *) GetNextDefrule(rulePtr);
}
}
}
void UpdateDeftemplateScope(
Environment *theEnv)
{
Deftemplate *theDeftemplate;
unsigned int moduleCount;
Defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*==================================*/
/* Loop through all of the modules. */
/*==================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*======================================================*/
/* Loop through each of the deftemplates in the module. */
/*======================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DeftemplateData(theEnv)->DeftemplateModuleIndex);
for (theDeftemplate = (Deftemplate *) theItem->firstItem;
theDeftemplate != NULL ;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
/*=======================================*/
/* If the deftemplate can be seen by the */
/* current module, then it is in scope. */
/*=======================================*/
if (FindImportedConstruct(theEnv,"deftemplate",theModule,
theDeftemplate->header.name->contents,
&moduleCount,true,NULL) != NULL)
{ theDeftemplate->inScope = true; }
else
{ theDeftemplate->inScope = false; }
}
}
}
globle void UpdateDeftemplateScope()
{
struct deftemplate *theDeftemplate;
int moduleCount;
struct defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*==================================*/
/* Loop through all of the modules. */
/*==================================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*======================================================*/
/* Loop through each of the deftemplates in the module. */
/*======================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theModule,DeftemplateModuleIndex);
for (theDeftemplate = (struct deftemplate *) theItem->firstItem;
theDeftemplate != NULL ;
theDeftemplate = (struct deftemplate *) GetNextDeftemplate(theDeftemplate))
{
/*=======================================*/
/* If the deftemplate can be seen by the */
/* current module, then it is in scope. */
/*=======================================*/
if (FindImportedConstruct("deftemplate",theModule,
ValueToString(theDeftemplate->header.name),
&moduleCount,TRUE,NULL) != NULL)
{ theDeftemplate->inScope = TRUE; }
else
{ theDeftemplate->inScope = FALSE; }
}
}
}
static void BloadBinaryItem()
{
unsigned long int space;
GenRead(&space,(unsigned long) sizeof(unsigned long int));
if (NumberOfDefmodules == 0) return;
BloadandRefresh(NumberOfDefmodules,(unsigned) sizeof(struct bsaveDefmodule),UpdateDefmodule);
BloadandRefresh(NumberOfPortItems,(unsigned) sizeof(struct bsavePortItem),UpdatePortItem);
SetListOfDefmodules((void *) DefmoduleArray);
SetCurrentModule((void *) GetNextDefmodule(NULL));
}
/*************************************************************************************
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);
}
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defrule *theDefrule;
#if FUZZY_DEFTEMPLATES
struct defrule *theDisjunct;
#endif
struct defmodule *theModule;
struct defruleModule *theModuleItem;
struct bsaveDefruleModule tempDefruleModule;
#if CERTAINTY_FACTORS
long int disjunctExpressionCountCF = 0L;
#endif
/*===============================================*/
/* Write out the space required by the defrules. */
/*===============================================*/
space = (NumberOfDefrules * sizeof(struct bsaveDefrule)) +
(NumberOfJoins * sizeof(struct bsaveJoinNode)) +
#if FUZZY_DEFTEMPLATES
(NumberOfPatternFuzzyValues * sizeof(struct fzSlotLocator)) +
#endif
(NumberOfDefruleModules * sizeof(struct bsaveDefruleModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*===============================================*/
/* Write out each defrule module data structure. */
/*===============================================*/
NumberOfDefrules = 0;
#if FUZZY_DEFTEMPLATES
NumberOfPatternFuzzyValues = 0;
#endif
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defruleModule *)
GetModuleItem(NULL,FindModuleItem("defrule")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefruleModule.header,
&theModuleItem->header);
GenWrite(&tempDefruleModule,(unsigned long) sizeof(struct bsaveDefruleModule),fp);
}
/*========================================*/
/* Write out each defrule data structure. */
/*========================================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{ BsaveDisjuncts(fp,theDefrule); }
}
#if FUZZY_DEFTEMPLATES
/*====================================*/
/* Write out the PatternFuzzyValues . */
/*====================================*/
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((VOID *) theModule);
theDefrule = (struct defrule *) GetNextDefrule(NULL);
while (theDefrule != NULL)
{
theDisjunct = theDefrule;
while (theDisjunct != NULL)
{
int i;
struct bsaveFzSlotLocator tempFZSlotLocator;
for (i=0; i<theDisjunct->numberOfFuzzySlots; i++)
{
FUZZY_VALUE_HN *fvhnPtr;
struct fzSlotLocator *fvSLPtr;
fvSLPtr = theDisjunct->pattern_fv_arrayPtr + i;
fvhnPtr = fvSLPtr->fvhnPtr;
tempFZSlotLocator.patternNum = fvSLPtr->patternNum;
tempFZSlotLocator.slotNum = fvSLPtr->slotNum;
tempFZSlotLocator.fvhnPtr = fvhnPtr->bucket;
GenWrite(&tempFZSlotLocator,(unsigned long) sizeof(struct bsaveFzSlotLocator),fp);
}
theDisjunct = theDisjunct->disjunct;
}
theDefrule = (struct defrule *) GetNextDefrule(theDefrule);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
}
#endif
/*=============================*/
/* Write out the Rete Network. */
/*=============================*/
MarkRuleNetwork(1);
BsaveJoins(fp);
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defrules, defrule modules, and joins in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefruleModules);
RestoreBloadCount(&NumberOfDefrules);
RestoreBloadCount(&NumberOfJoins);
#if FUZZY_DEFTEMPLATES
RestoreBloadCount(&NumberOfPatternFuzzyValues);
#endif
}
}
static void BsaveFind()
{
struct defrule *theDefrule, *theDisjunct;
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(NumberOfDefruleModules);
SaveBloadCount(NumberOfDefrules);
SaveBloadCount(NumberOfJoins);
#if FUZZY_DEFTEMPLATES
SaveBloadCount(NumberOfPatternFuzzyValues);
#endif
}
/*====================================================*/
/* Set the binary save ID for defrule data structures */
/* and count the number of each type. */
/*====================================================*/
TagRuleNetwork(&NumberOfDefruleModules,&NumberOfDefrules,&NumberOfJoins);
#if FUZZY_DEFTEMPLATES
NumberOfPatternFuzzyValues = 0;
#endif
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*============================*/
/* Set the current module to */
/* the module being examined. */
/*============================*/
SetCurrentModule((void *) theModule);
/*==================================================*/
/* Loop through each defrule in the current module. */
/*==================================================*/
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{
/*================================================*/
/* Initialize the construct header for the binary */
/* save. The binary save ID has already been set. */
/*================================================*/
MarkConstructHeaderNeededItems(&theDefrule->header,theDefrule->header.bsaveID);
/*===========================================*/
/* Count and mark data structures associated */
/* with dynamic salience. */
/*===========================================*/
#if DYNAMIC_SALIENCE
ExpressionCount += ExpressionSize(theDefrule->dynamicSalience);
MarkNeededItems(theDefrule->dynamicSalience);
#endif
#if CERTAINTY_FACTORS
ExpressionCount += ExpressionSize(theDefrule->dynamicCF);
MarkNeededItems(theDefrule->dynamicCF);
#endif
/*==========================================*/
/* Loop through each disjunct of the rule */
/* counting and marking the data structures */
/* associated with RHS actions. */
/*==========================================*/
for (theDisjunct = theDefrule;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct)
{
ExpressionCount += ExpressionSize(theDisjunct->actions);
MarkNeededItems(theDisjunct->actions);
#if FUZZY_DEFTEMPLATES
/* count the number of PatternFuzzyValues store with each rule
and mark all of the FuzzyValues pointed to as needed
*/
if (theDisjunct->numberOfFuzzySlots > 0)
{ int i;
FUZZY_VALUE_HN *fvhnPtr;
struct fzSlotLocator *fvSLPtr;
NumberOfPatternFuzzyValues += theDisjunct->numberOfFuzzySlots;
for (i= 0; i<theDisjunct->numberOfFuzzySlots; i++)
{
fvSLPtr = theDisjunct->pattern_fv_arrayPtr + i;
fvhnPtr = fvSLPtr->fvhnPtr;
if (fvhnPtr != NULL)
{ fvhnPtr->neededFuzzyValue = TRUE;
}
}
}
#endif
}
}
}
/*===============================*/
/* Reset the bsave tags assigned */
/* to defrule data structures. */
/*===============================*/
MarkRuleNetwork(1);
}
/*******************************************************
NAME : DefmessageHandlerWatchSupport
DESCRIPTION : Sets or displays handlers specified
INPUTS : 1) The calling function name
2) The logical output name for displays
(can be NULL)
4) The new set state (can be -1)
5) The print function (can be NULL)
6) The trace function (can be NULL)
7) The handlers expression list
RETURNS : TRUE if all OK,
FALSE otherwise
SIDE EFFECTS : Handler trace flags set or displayed
NOTES : None
*******************************************************/
static BOOLEAN DefmessageHandlerWatchSupport(
char *funcName,
char *log,
int newState,
void (*printFunc)(char *,void *,unsigned),
void (*traceFunc)(int,void *,unsigned),
EXPRESSION *argExprs)
{
struct defmodule *theModule;
void *theClass;
char *theHandlerStr;
int theType;
int argIndex = 2;
DATA_OBJECT tmpData;
/* ===============================
If no handlers are specified,
show the trace for all handlers
in all handlers
=============================== */
if (argExprs == NULL)
{
SaveCurrentModule();
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((void *) theModule);
if (traceFunc == NULL)
{
PrintRouter(log,GetDefmoduleName((void *) theModule));
PrintRouter(log,":\n");
}
theClass = GetNextDefclass(NULL);
while (theClass != NULL)
{
if (WatchClassHandlers(theClass,NULL,-1,log,newState,
TRUE,printFunc,traceFunc) == FALSE)
return(FALSE);
theClass = GetNextDefclass(theClass);
}
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
RestoreCurrentModule();
return(TRUE);
}
/* ================================================
Set or show the traces for the specified handler
================================================ */
while (argExprs != NULL)
{
if (EvaluateExpression(argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(funcName,argIndex,"class name");
return(FALSE);
}
theClass = (void *) LookupDefclassByMdlOrScope(DOToString(tmpData));
if (theClass == NULL)
{
ExpectedTypeError1(funcName,argIndex,"class name");
return(FALSE);
}
if (GetNextArgument(argExprs) != NULL)
{
argExprs = GetNextArgument(argExprs);
argIndex++;
if (EvaluateExpression(argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(funcName,argIndex,"handler name");
return(FALSE);
}
theHandlerStr = DOToString(tmpData);
if (GetNextArgument(argExprs) != NULL)
{
argExprs = GetNextArgument(argExprs);
argIndex++;
if (EvaluateExpression(argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(funcName,argIndex,"handler type");
return(FALSE);
}
if ((theType = HandlerType(funcName,DOToString(tmpData))) == MERROR)
return(FALSE);
}
else
theType = -1;
}
else
{
theHandlerStr = NULL;
theType = -1;
}
if (WatchClassHandlers(theClass,theHandlerStr,theType,log,
newState,FALSE,printFunc,traceFunc) == FALSE)
{
ExpectedTypeError1(funcName,argIndex,"handler");
return(FALSE);
}
argIndex++;
argExprs = GetNextArgument(argExprs);
}
return(TRUE);
}
/*******************************************************
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);
}
/****************************************************************************************
NAME : BsaveGenerics
DESCRIPTION : Writes out generic function in binary format
Space required (unsigned long)
All generic modules (sizeof(DEFGENERIC_MODULE) * Number of generic modules)
All generic headers (sizeof(DEFGENERIC) * Number of generics)
All methods (sizeof(DEFMETHOD) * Number of methods)
All method restrictions (sizeof(RESTRICTION) * Number of restrictions)
All restriction type arrays (sizeof(void *) * # of types)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
****************************************************************************************/
static void BsaveGenerics(
FILE *fp)
{
struct defmodule *theModule;
DEFGENERIC_MODULE *theModuleItem;
unsigned long space;
BSAVE_DEFGENERIC_MODULE dummy_generic_module;
/* =====================================================================
Space is: Sum over all structures(sizeof(structure) * structure-cnt))
===================================================================== */
space = ((unsigned long) ModuleCount * (unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE)) +
((unsigned long) GenericCount * (unsigned long) sizeof(BSAVE_GENERIC)) +
((unsigned long) MethodCount * (unsigned long) sizeof(BSAVE_METHOD)) +
((unsigned long) RestrictionCount * (unsigned long) sizeof(BSAVE_RESTRICTION)) +
((unsigned long) TypeCount * (unsigned long) sizeof(unsigned long));
/* ================================================================
Write out the total amount of space required: modules,headers,
methods, restrictions, types
================================================================ */
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* ======================================
Write out the generic function modules
====================================== */
GenericCount = 0L;
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFGENERIC_MODULE *)
GetModuleItem(theModule,FindModuleItem("defgeneric")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_generic_module.header,
&theModuleItem->header);
GenWrite((void *) &dummy_generic_module,
(unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* ======================================
Write out the generic function headers
====================================== */
MethodCount = 0L;
DoForAllConstructs(BsaveDefgenericHeader,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =====================
Write out the methods
===================== */
RestrictionCount = 0L;
DoForAllConstructs(BsaveMethods,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =================================
Write out the method restrictions
================================= */
TypeCount = 0L;
DoForAllConstructs(BsaveMethodRestrictions,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =============================================================
Finally, write out the type lists for the method restrictions
============================================================= */
DoForAllConstructs(BsaveRestrictionTypes,DefgenericModuleIndex,
FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&GenericCount);
RestoreBloadCount(&MethodCount);
RestoreBloadCount(&RestrictionCount);
RestoreBloadCount(&TypeCount);
}
}
static void BsaveFind(
Environment *theEnv)
{
Deftemplate *theDeftemplate;
struct templateSlot *theSlot;
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. */
/*=======================================================*/
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfDeftemplates);
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots);
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfTemplateModules);
/*==================================================*/
/* Set the count of deftemplates, deftemplate slots */
/* and deftemplate module data structures to zero. */
/*==================================================*/
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates = 0;
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots = 0;
DeftemplateBinaryData(theEnv)->NumberOfTemplateModules = 0;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*============================================*/
/* Set the current module to the module being */
/* examined and increment the number of */
/* deftemplate modules encountered. */
/*============================================*/
SetCurrentModule(theEnv,theModule);
DeftemplateBinaryData(theEnv)->NumberOfTemplateModules++;
/*======================================================*/
/* Loop through each deftemplate in the current module. */
/*======================================================*/
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
/*======================================================*/
/* Initialize the construct header for the binary save. */
/*======================================================*/
MarkConstructHeaderNeededItems(&theDeftemplate->header,
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates++);
/*=============================================================*/
/* Loop through each slot in the deftemplate, incrementing the */
/* slot count and marking the slot names as needed symbols. */
/*=============================================================*/
for (theSlot = theDeftemplate->slotList;
theSlot != NULL;
theSlot = theSlot->next)
{
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots++;
theSlot->slotName->neededSymbol = true;
}
}
}
}
static void BsaveBinaryItem(
Environment *theEnv,
FILE *fp)
{
size_t space;
Deftemplate *theDeftemplate;
struct bsaveDeftemplate tempDeftemplate;
struct templateSlot *theSlot;
struct bsaveTemplateSlot tempTemplateSlot;
struct bsaveDeftemplateModule tempTemplateModule;
Defmodule *theModule;
struct deftemplateModule *theModuleItem;
/*============================================================*/
/* Write out the amount of space taken up by the deftemplate, */
/* deftemplateModule, and templateSlot data structures in the */
/* binary image. */
/*============================================================*/
space = (DeftemplateBinaryData(theEnv)->NumberOfDeftemplates * sizeof(struct bsaveDeftemplate)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots * sizeof(struct bsaveTemplateSlot)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateModules * sizeof(struct bsaveDeftemplateModule));
GenWrite(&space,sizeof(size_t),fp);
/*===================================================*/
/* Write out each deftemplate module data structure. */
/*===================================================*/
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
theModuleItem = (struct deftemplateModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"deftemplate")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempTemplateModule.header,
&theModuleItem->header);
GenWrite(&tempTemplateModule,sizeof(struct bsaveDeftemplateModule),fp);
}
/*============================================*/
/* Write out each deftemplate data structure. */
/*============================================*/
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
AssignBsaveConstructHeaderVals(&tempDeftemplate.header,
&theDeftemplate->header);
tempDeftemplate.implied = theDeftemplate->implied;
tempDeftemplate.numberOfSlots = theDeftemplate->numberOfSlots;
tempDeftemplate.patternNetwork = BsaveFactPatternIndex(theDeftemplate->patternNetwork);
if (theDeftemplate->slotList != NULL)
{ tempDeftemplate.slotList = DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots; }
else
{ tempDeftemplate.slotList = ULONG_MAX; }
GenWrite(&tempDeftemplate,sizeof(struct bsaveDeftemplate),fp);
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots += theDeftemplate->numberOfSlots;
}
}
/*=============================================*/
/* Write out each templateSlot data structure. */
/*=============================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
for (theSlot = theDeftemplate->slotList;
theSlot != NULL;
theSlot = theSlot->next)
{
tempTemplateSlot.constraints = ConstraintIndex(theSlot->constraints);
tempTemplateSlot.slotName = theSlot->slotName->bucket;
tempTemplateSlot.multislot = theSlot->multislot;
tempTemplateSlot.noDefault = theSlot->noDefault;
tempTemplateSlot.defaultPresent = theSlot->defaultPresent;
tempTemplateSlot.defaultDynamic = theSlot->defaultDynamic;
tempTemplateSlot.defaultList = HashedExpressionIndex(theEnv,theSlot->defaultList);
tempTemplateSlot.facetList = HashedExpressionIndex(theEnv,theSlot->facetList);
if (theSlot->next != NULL) tempTemplateSlot.next = 0L;
else tempTemplateSlot.next = ULONG_MAX;
GenWrite(&tempTemplateSlot,sizeof(struct bsaveTemplateSlot),fp);
}
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of deftemplates, deftemplate modules, and deftemplate slots */
/* in the binary image (these were overwritten by the binary */
/* save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfDeftemplates);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateModules);
}
/*************************************************************************************
NAME : BsaveObjects
DESCRIPTION : Writes out classes and message-handlers in binary format
Space required (unsigned long)
Followed by the data structures in order
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveObjects(
FILE *fp)
{
UNLN space;
struct defmodule *theModule;
DEFCLASS_MODULE *theModuleItem;
BSAVE_DEFCLASS_MODULE dummy_mitem;
BSAVE_SLOT_NAME dummy_slot_name;
SLOT_NAME *snp;
register unsigned i;
if ((ClassCount == 0L) && (HandlerCount == 0L))
{
space = 0L;
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
return;
}
space = (ModuleCount * (UNLN) sizeof(BSAVE_DEFCLASS_MODULE)) +
(ClassCount * (UNLN) sizeof(BSAVE_DEFCLASS)) +
(LinkCount * (UNLN) sizeof(long)) +
(SlotCount * (UNLN) sizeof(BSAVE_SLOT_DESC)) +
(SlotNameCount * (UNLN) sizeof(BSAVE_SLOT_NAME)) +
(TemplateSlotCount * (UNLN) sizeof(long)) +
(SlotNameMapCount * (UNLN) sizeof(unsigned)) +
(HandlerCount * (UNLN) sizeof(BSAVE_HANDLER)) +
(HandlerCount * (UNLN) sizeof(unsigned));
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
ClassCount = 0L;
LinkCount = 0L;
SlotCount = 0L;
SlotNameCount = 0L;
TemplateSlotCount = 0L;
SlotNameMapCount = 0L;
HandlerCount = 0L;
/* =================================
Write out each defclass module
================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFCLASS_MODULE *)
GetModuleItem(theModule,FindModuleItem("defclass")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFCLASS_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* =====================
Write out the classes
===================== */
DoForAllConstructs(BsaveDefclass,DefclassModuleIndex,FALSE,(void *) fp);
/* =========================
Write out the class links
========================= */
LinkCount = 0L;
DoForAllConstructs(BsaveClassLinks,DefclassModuleIndex,FALSE,(void *) fp);
/* ===============================
Write out the slot name entries
=============================== */
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))
{
dummy_slot_name.id = snp->id;
dummy_slot_name.hashTableIndex = snp->hashTableIndex;
dummy_slot_name.name = (long) snp->name->bucket;
dummy_slot_name.putHandlerName = (long) snp->putHandlerName->bucket;
GenWrite((void *) &dummy_slot_name,(UNLN) sizeof(BSAVE_SLOT_NAME),fp);
}
}
/* ===================
Write out the slots
=================== */
DoForAllConstructs(BsaveSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =====================================
Write out the template instance slots
===================================== */
DoForAllConstructs(BsaveTemplateSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =============================================
Write out the ordered instance slot name maps
============================================= */
DoForAllConstructs(BsaveSlotMap,DefclassModuleIndex,FALSE,(void *) fp);
/* ==============================
Write out the message-handlers
============================== */
DoForAllConstructs(BsaveHandlers,DefclassModuleIndex,FALSE,(void *) fp);
/* ==========================================
Write out the ordered message-handler maps
========================================== */
DoForAllConstructs(BsaveHandlerMap,DefclassModuleIndex,FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&ClassCount);
RestoreBloadCount(&LinkCount);
RestoreBloadCount(&SlotCount);
RestoreBloadCount(&SlotNameCount);
RestoreBloadCount(&TemplateSlotCount);
RestoreBloadCount(&SlotNameMapCount);
RestoreBloadCount(&HandlerCount);
}
}
static int ConstructToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct defrule *theDefrule;
struct joinNode *theJoin;
int joinArrayCount = 0, joinArrayVersion = 1;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int defruleArrayCount = 0, defruleArrayVersion = 1;
FILE *joinFile = NULL, *moduleFile = NULL, *defruleFile = NULL;
#if FUZZY_DEFTEMPLATES
struct fzSlotLocator *thePatternFv;
int patternFvArrayCount = 0, patternFvArrayVersion = 1;
FILE *patternFvFile = NULL;
#endif
/*==============================================*/
/* Include the appropriate defrule header file. */
/*==============================================*/
fprintf(headerFP,"#include \"ruledef.h\"\n");
/*=========================================================*/
/* Loop through all the modules, all the defrules, and all */
/* the join nodes writing their C code representation to */
/* the file as they are traversed. */
/*=========================================================*/
#if FUZZY_DEFTEMPLATES
/*=========================================================*/
/* ALSO write the patternFv arrays as required if Fuzzy */
/*=========================================================*/
#endif
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
SetCurrentModule((void *) theModule);
/*==========================*/
/* Save the defrule module. */
/*==========================*/
moduleFile = OpenFileIfNeeded(moduleFile,fileName,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"struct defruleModule",ModulePrefix(DefruleCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
DefruleModuleToCode(moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
/*=========================================*/
/* Loop through all of the defrules (and */
/* their disjuncts) in the current module. */
/*=========================================*/
theDefrule = (struct defrule *) GetNextDefrule(NULL);
while (theDefrule != NULL)
{
/*===================================*/
/* Save the defrule data structures. */
/*===================================*/
defruleFile = OpenFileIfNeeded(defruleFile,fileName,fileID,imageID,&fileCount,
defruleArrayVersion,headerFP,
"struct defrule",ConstructPrefix(DefruleCodeItem),
FALSE,NULL);
if (defruleFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
#if FUZZY_DEFTEMPLATES
DefruleToCode(defruleFile,theDefrule,imageID,maxIndices,
moduleCount, patternFvArrayCount, patternFvArrayVersion);
#else
DefruleToCode(defruleFile,theDefrule,imageID,maxIndices,
moduleCount);
#endif
defruleArrayCount++;
defruleFile = CloseFileIfNeeded(defruleFile,&defruleArrayCount,&defruleArrayVersion,
maxIndices,NULL,NULL);
#if FUZZY_DEFTEMPLATES
/* write out the patternFv array of fzSlotLocator structs */
thePatternFv = theDefrule->pattern_fv_arrayPtr;
if (thePatternFv != NULL)
{
int i;
int numFzSlots = theDefrule->numberOfFuzzySlots;
patternFvFile = OpenFileIfNeeded(patternFvFile,fileName,fileID,imageID,&fileCount,
patternFvArrayVersion,headerFP,
"struct fzSlotLocator",PatternFvPrefix(),FALSE,NULL);
if (patternFvFile == NULL)
{
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
return(0);
}
for (i=0; i< numFzSlots; i++)
{
fprintf(patternFvFile, "{%d, %d, ",
thePatternFv[i].patternNum, thePatternFv[i].slotNum);
PrintFuzzyValueReference(patternFvFile,thePatternFv[i].fvhnPtr);
fprintf(patternFvFile, "}");
if (i != numFzSlots-1)
fprintf(patternFvFile, ",");
}
patternFvArrayCount += numFzSlots;
patternFvFile = CloseFileIfNeeded(patternFvFile,&patternFvArrayCount,&patternFvArrayVersion,
maxIndices,NULL,NULL);
}
#endif
/*================================*/
/* Save the join data structures. */
/*================================*/
for (theJoin = theDefrule->lastJoin;
theJoin != NULL;
theJoin = GetPreviousJoin(theJoin))
{
if (theJoin->marked)
{
joinFile = OpenFileIfNeeded(joinFile,fileName,fileID,imageID,&fileCount,
joinArrayVersion,headerFP,
"struct joinNode",JoinPrefix(),FALSE,NULL);
if (joinFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
JoinToCode(joinFile,theJoin,imageID,maxIndices);
joinArrayCount++;
joinFile = CloseFileIfNeeded(joinFile,&joinArrayCount,&joinArrayVersion,
maxIndices,NULL,NULL);
}
}
/*==========================================*/
/* Move on to the next disjunct or defrule. */
/*==========================================*/
if (theDefrule->disjunct != NULL) theDefrule = theDefrule->disjunct;
else theDefrule = (struct defrule *) GetNextDefrule(theDefrule);
}
moduleCount++;
moduleArrayCount++;
}
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(1);
}
Defglobal *GetNextDefglobalInScope(
Environment *theEnv,
Defglobal *theGlobal)
{
struct defmoduleItemHeader *theItem;
/*=======================================*/
/* If we're beginning the search for the */
/* first defglobal in scope, then ... */
/*=======================================*/
if (theGlobal == NULL)
{
/*==============================================*/
/* If the current module has been changed since */
/* the last time the scopes were computed, then */
/* recompute the scopes. */
/*==============================================*/
if (DefglobalData(theEnv)->LastModuleIndex != DefmoduleData(theEnv)->ModuleChangeIndex)
{
UpdateDefglobalScope(theEnv);
DefglobalData(theEnv)->LastModuleIndex = DefmoduleData(theEnv)->ModuleChangeIndex;
}
/*==========================================*/
/* Get the first module and first defglobal */
/* to start the search with. */
/*==========================================*/
DefglobalData(theEnv)->TheDefmodule = GetNextDefmodule(theEnv,NULL);
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,DefglobalData(theEnv)->TheDefmodule,DefglobalData(theEnv)->DefglobalModuleIndex);
theGlobal = (Defglobal *) theItem->firstItem;
}
/*==================================================*/
/* Otherwise, see if the last defglobal returned by */
/* this function has a defglobal following it. */
/*==================================================*/
else
{ theGlobal = GetNextDefglobal(theEnv,theGlobal); }
/*======================================*/
/* Continue looping through the modules */
/* until a defglobal in scope is found. */
/*======================================*/
while (DefglobalData(theEnv)->TheDefmodule != NULL)
{
/*=====================================================*/
/* Loop through the defglobals in the module currently */
/* being examined to see if one is in scope. */
/*=====================================================*/
for (;
theGlobal != NULL;
theGlobal = GetNextDefglobal(theEnv,theGlobal))
{ if (theGlobal->inScope) return theGlobal; }
/*================================================*/
/* If a global in scope couldn't be found in this */
/* module, then move on to the next module. */
/*================================================*/
DefglobalData(theEnv)->TheDefmodule = GetNextDefmodule(theEnv,DefglobalData(theEnv)->TheDefmodule);
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,DefglobalData(theEnv)->TheDefmodule,DefglobalData(theEnv)->DefglobalModuleIndex);
theGlobal = (Defglobal *) theItem->firstItem;
}
/*====================================*/
/* All the globals in scope have been */
/* traversed and there are none left. */
/*====================================*/
return NULL;
}
bool Save(
Environment *theEnv,
const char *fileName)
{
struct saveCallFunctionItem *saveFunction;
FILE *filePtr;
Defmodule *defmodulePtr;
bool updated = false;
bool unvisited = true;
/*=====================================*/
/* If embedded, clear the error flags. */
/*=====================================*/
if (EvaluationData(theEnv)->CurrentExpression == NULL)
{ ResetErrorFlags(theEnv); }
/*=====================*/
/* Open the save file. */
/*=====================*/
if ((filePtr = GenOpen(theEnv,fileName,"w")) == NULL)
{ return false; }
/*===========================*/
/* Bypass the router system. */
/*===========================*/
SetFastSave(theEnv,filePtr);
/*================================*/
/* Mark all modules as unvisited. */
/*================================*/
MarkModulesAsUnvisited(theEnv);
/*===============================================*/
/* Save the constructs. Repeatedly loop over the */
/* modules until each module has been save. */
/*===============================================*/
while (unvisited)
{
unvisited = false;
updated = false;
for (defmodulePtr = GetNextDefmodule(theEnv,NULL);
defmodulePtr != NULL;
defmodulePtr = GetNextDefmodule(theEnv,defmodulePtr))
{
/*=================================================================*/
/* We only want to save a module if all of the modules it imports */
/* from have already been saved. Since there can't be circular */
/* dependencies in imported modules, this should save the modules */
/* that don't import anything first and then work back from those. */
/*=================================================================*/
if (defmodulePtr->visitedFlag)
{ /* Module has already been saved. */ }
else if (AllImportedModulesVisited(theEnv,defmodulePtr))
{
for (saveFunction = ConstructData(theEnv)->ListOfSaveFunctions;
saveFunction != NULL;
saveFunction = saveFunction->next)
{ (*saveFunction->func)(theEnv,defmodulePtr,(char *) filePtr,saveFunction->context); }
updated = true;
defmodulePtr->visitedFlag = true;
}
else
{ unvisited = true; }
}
/*=====================================================================*/
/* At least one module should be saved in every pass. If all have been */
/* visited/saved, then both flags will be false. If all remaining */
/* unvisited/unsaved modules were visited/saved, then unvisited will */
/* be false and updated will be true. If some, but not all, remaining */
/* unvisited/unsaved modules are visited/saved, then unvisited will */
/* be true and updated will be true. This leaves the case where there */
/* are remaining unvisited/unsaved modules, but none were */
/* visited/saved: unvisited is true and updated is false. */
/*=====================================================================*/
if (unvisited && (! updated))
{
SystemError(theEnv,"CONSTRCT",2);
break;
}
}
/*======================*/
/* Close the save file. */
/*======================*/
GenClose(theEnv,filePtr);
/*===========================*/
/* Remove the router bypass. */
/*===========================*/
SetFastSave(theEnv,NULL);
/*=========================*/
/* Return true to indicate */
/* successful completion. */
/*=========================*/
return true;
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defglobal *theDefglobal;
struct bsaveDefglobal newDefglobal;
struct defmodule *theModule;
struct bsaveDefglobalModule tempDefglobalModule;
struct defglobalModule *theModuleItem;
/*==========================================================*/
/* Write out the amount of space taken up by the defglobal */
/* and defglobalModule data structures in the binary image. */
/*==========================================================*/
space = NumberOfDefglobals * sizeof(struct bsaveDefglobal) +
(NumberOfDefglobalModules * sizeof(struct bsaveDefglobalModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*=================================================*/
/* Write out each defglobal module data structure. */
/*=================================================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defglobalModule *)
GetModuleItem(NULL,FindModuleItem("defglobal")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefglobalModule.header,
&theModuleItem->header);
GenWrite(&tempDefglobalModule,(unsigned long) sizeof(struct bsaveDefglobalModule),fp);
}
/*===========================*/
/* Write out each defglobal. */
/*===========================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefglobal = (struct defglobal *) GetNextDefglobal(NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) GetNextDefglobal(theDefglobal))
{
AssignBsaveConstructHeaderVals(&newDefglobal.header,
&theDefglobal->header);
newDefglobal.initial = HashedExpressionIndex(theDefglobal->initial);
GenWrite(&newDefglobal,(unsigned long) sizeof(struct bsaveDefglobal),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defglobals and defglobal modules in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefglobalModules);
RestoreBloadCount(&NumberOfDefglobals);
}
}
/*******************************************************
NAME : DefinstancesToCode
DESCRIPTION : Writes out static array code for
definstances
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 definstances, 0 on errors,
1 if definstances written
SIDE EFFECTS : Code written to files
NOTES : None
*******************************************************/
static int DefinstancesToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
DEFINSTANCES *theDefinstances;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int definstancesArrayCount = 0, definstancesArrayVersion = 1;
FILE *moduleFile = NULL, *definstancesFile = NULL;
/* ================================================
Include the appropriate definstances header file
================================================ */
fprintf(headerFP,"#include \"defins.h\"\n");
/* =============================================================
Loop through all the modules and all the definstances writing
their C code representation to the file as they are traversed
============================================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((void *) theModule);
moduleFile = OpenFileIfNeeded(moduleFile,fileName,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"DEFINSTANCES_MODULE",ModulePrefix(DefinstancesCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
CloseDefinstancesFiles(moduleFile,definstancesFile,maxIndices);
return(0);
}
DefinstancesModuleToCode(moduleFile,theModule,imageID,maxIndices);
moduleFile = CloseFileIfNeeded(moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
theDefinstances = (DEFINSTANCES *) GetNextDefinstances(NULL);
while (theDefinstances != NULL)
{
definstancesFile = OpenFileIfNeeded(definstancesFile,fileName,fileID,imageID,&fileCount,
definstancesArrayVersion,headerFP,
"DEFINSTANCES",ConstructPrefix(DefinstancesCodeItem),
FALSE,NULL);
if (definstancesFile == NULL)
{
CloseDefinstancesFiles(moduleFile,definstancesFile,maxIndices);
return(0);
}
SingleDefinstancesToCode(definstancesFile,theDefinstances,imageID,
maxIndices,moduleCount);
definstancesArrayCount++;
definstancesFile = CloseFileIfNeeded(definstancesFile,&definstancesArrayCount,
&definstancesArrayVersion,maxIndices,NULL,NULL);
theDefinstances = (DEFINSTANCES *) GetNextDefinstances(theDefinstances);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
moduleCount++;
moduleArrayCount++;
}
CloseDefinstancesFiles(moduleFile,definstancesFile,maxIndices);
return(1);
}
static int PatternNetworkToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct deftemplate *theTemplate;
struct factPatternNode *thePatternNode;
int networkArrayCount = 0, networkArrayVersion = 1;
FILE *networkFile = NULL;
/*===========================================================*/
/* Include the appropriate fact pattern network header file. */
/*===========================================================*/
fprintf(headerFP,"#include \"factbld.h\"\n");
/*===============================*/
/* Loop through all the modules. */
/*===============================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
SetCurrentModule((void *) theModule);
/*======================================*/
/* Loop through all of the deftemplates */
/* in the current module. */
/*======================================*/
for (theTemplate = (struct deftemplate *) GetNextDeftemplate(NULL);
theTemplate != NULL;
theTemplate = (struct deftemplate *) GetNextDeftemplate(theTemplate))
{
/*======================================================*/
/* Loop through each pattern node in the deftemplate's */
/* pattern network writing its C code representation to */
/* the file as it is traversed. */
/*======================================================*/
for (thePatternNode = theTemplate->patternNetwork;
thePatternNode != NULL;
thePatternNode = GetNextPatternNode(thePatternNode))
{
networkFile = OpenFileIfNeeded(networkFile,fileName,fileID,imageID,&fileCount,
networkArrayVersion,headerFP,
"struct factPatternNode",FactPrefix(),FALSE,NULL);
if (networkFile == NULL)
{
CloseNetworkFiles(networkFile,maxIndices);
return(0);
}
PatternNodeToCode(networkFile,thePatternNode,imageID,maxIndices);
networkArrayCount++;
networkFile = CloseFileIfNeeded(networkFile,&networkArrayCount,
&networkArrayVersion,maxIndices,NULL,NULL);
}
}
}
/*==============================*/
/* Close any C files left open. */
/*==============================*/
CloseNetworkFiles(networkFile,maxIndices);
/*===============================*/
/* Return TRUE to indicate the C */
/* code was successfully saved. */
/*===============================*/
return(TRUE);
}
static void ClearBload()
{
unsigned long int space;
long i;
struct patternParser *theParser = NULL;
struct patternEntity *theEntity = NULL;
void *theModule;
/*===========================================*/
/* Delete all known entities before removing */
/* the defrule data structures. */
/*===========================================*/
GetNextPatternEntity(&theParser,&theEntity);
while (theEntity != NULL)
{
(*theEntity->theInfo->base.deleteFunction)(theEntity);
theEntity = NULL;
GetNextPatternEntity(&theParser,&theEntity);
}
/*=========================================*/
/* Remove all activations from the agenda. */
/*=========================================*/
SaveCurrentModule();
for (theModule = GetNextDefmodule(NULL);
theModule != NULL;
theModule = GetNextDefmodule(theModule))
{
SetCurrentModule(theModule);
RemoveAllActivations();
}
RestoreCurrentModule();
ClearFocusStack();
/*==========================================================*/
/* Remove all partial matches from the beta memories in the */
/* join network. Alpha memories do not need to be examined */
/* since all pattern entities have been deleted by now. */
/*==========================================================*/
for (i = 0; i < NumberOfJoins; i++)
{ FlushAlphaBetaMemory(JoinArray[i].beta); }
/*================================================*/
/* Decrement the symbol count for each rule name. */
/*================================================*/
for (i = 0; i < NumberOfDefrules; i++)
{ UnmarkConstructHeader(&DefruleArray[i].header); }
/*==================================================*/
/* Return the space allocated for the bload arrays. */
/*==================================================*/
space = NumberOfDefruleModules * sizeof(struct defruleModule);
if (space != 0) genlongfree((void *) ModuleArray,space);
space = NumberOfDefrules * sizeof(struct defrule);
if (space != 0) genlongfree((void *) DefruleArray,space);
#if FUZZY_DEFTEMPLATES
space = NumberOfPatternFuzzyValues * sizeof(struct fzSlotLocator);
if (space != 0) genlongfree((void *) PatternFuzzyValueArray,space);
#endif
space = NumberOfJoins * sizeof(struct joinNode);
if (space != 0) genlongfree((void *) JoinArray,space);
}
static bool ConstructToCode(
Environment *theEnv,
const char *fileName,
const char *pathName,
char *fileNameBuffer,
unsigned int fileID,
FILE *headerFP,
unsigned int imageID,
unsigned int maxIndices)
{
unsigned int fileCount = 1;
Defmodule *theModule;
Defglobal *theDefglobal;
unsigned int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
unsigned int defglobalArrayCount = 0, defglobalArrayVersion = 1;
FILE *moduleFile = NULL, *defglobalFile = NULL;
/*================================================*/
/* Include the appropriate defglobal header file. */
/*================================================*/
fprintf(headerFP,"#include \"globldef.h\"\n");
/*===================================================================*/
/* Loop through all the modules and all the defglobals writing their */
/* C code representation to the file as they are traversed. */
/*===================================================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"struct defglobalModule",ModulePrefix(DefglobalData(theEnv)->DefglobalCodeItem),
false,NULL);
if (moduleFile == NULL)
{
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return false;
}
DefglobalModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
for (theDefglobal = GetNextDefglobal(theEnv,NULL);
theDefglobal != NULL;
theDefglobal = GetNextDefglobal(theEnv,theDefglobal))
{
defglobalFile = OpenFileIfNeeded(theEnv,defglobalFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
defglobalArrayVersion,headerFP,
"Defglobal",ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem),
false,NULL);
if (defglobalFile == NULL)
{
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return false;
}
DefglobalToCode(theEnv,defglobalFile,theDefglobal,imageID,maxIndices,moduleCount);
defglobalArrayCount++;
defglobalFile = CloseFileIfNeeded(theEnv,defglobalFile,&defglobalArrayCount,
&defglobalArrayVersion,maxIndices,NULL,NULL);
}
moduleCount++;
moduleArrayCount++;
}
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return true;
}
