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 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);
}
}
}
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 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);
}
}
}
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);
}
BOOL FAR PASCAL ExecDlg (
HWND hDlg,
unsigned message,
WORD wParam,
LONG lParam)
{ switch (message)
{ case WM_INITDIALOG:
{ WPARAM item;
SetWindowText ( hDlg, (LPSTR)"Execution Options" );
/*-----------------------------+
| Initalize Strategy Combo Box |
+-----------------------------*/
#if CONFLICT_RESOLUTION_STRATEGIES
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Depth"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Breadth"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "LEX"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "MEA"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Complexity"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Simplicity"));
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Random"));
switch ( GetStrategy())
{ case DEPTH_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Depth"));
break;
case BREADTH_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Breadth"));
break;
case LEX_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"LEX"));
break;
case MEA_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"MEA"));
break;
case COMPLEXITY_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Complexity"));
break;
case SIMPLICITY_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Simplicity"));
break;
case RANDOM_STRATEGY:
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Random"));
break;
}
#else
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Depth"));
item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Depth"));
#endif
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_SETCURSEL, item, 0);
/*-----------------------------+
| Initalize Salience Combo Box |
+-----------------------------*/
#if DYNAMIC_SALIENCE
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Activated"));
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Every Cycle"));
switch (GetSalienceEvaluation())
{ case WHEN_DEFINED:
item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
break;
case WHEN_ACTIVATED:
item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Activated"));
break;
case EVERY_CYCLE:
item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "Every Cycle"));
break;
}
#else
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
item = SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
#endif
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_SETCURSEL, item, 0);
/*-----------------------------------+
| Disable Incremental reset check box |
| if any rules are in the system. |
+------------------------------------*/
if ( GetNextDefrule (NULL) != NULL )
{ EnableWindow(GetDlgItem(hDlg, IDC_WATCH_ALL ), TRUE);
}
/*----------------------------+
| Initalize Other Check Boxes |
+----------------------------*/
SetCheckBox(hDlg, IDC_EXE_STATIC, GetStaticConstraintChecking());
SetCheckBox(hDlg, IDC_EXE_DYNAMIC, GetDynamicConstraintChecking());
SetCheckBox(hDlg, IDC_EXE_AUTO, GetAutoFloatDividend());
#if DEFGLOBAL_CONSTRUCT
SetCheckBox(hDlg, IDC_EXE_GLOBAL, GetResetGlobals());
#endif
#if DEFTEMPLATE_CONSTRUCT
SetCheckBox(hDlg, IDC_EXE_FACT, GetFactDuplication());
#endif
#if INCREMENTAL_RESET & (! RUN_TIME)
SetCheckBox(hDlg, IDC_EXE_RESET, GetIncrementalReset());
#endif
#if (!RUN_TIME)
SetCheckBox(hDlg, IDC_EXE_SEQUENCE, GetSequenceOperatorRecognition());
#endif
return (TRUE);
}
case WM_COMMAND:
{ switch ( wParam )
{ case IDC_OK:
{ int value;
char Msg[40];
#if DYNAMIC_SALIENCE
/*--------------------------+
| Decode Salience Combo Box |
+--------------------------*/
value = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_GETCURSEL, 0, 0);
SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_GETLBTEXT, value, (LONG)Msg );
if ( strcmp (Msg, "When Defined" ) == 0 )
SetSalienceEvaluation(WHEN_DEFINED);
else if (strcmp(Msg, "When Activated" ) == 0)
SetSalienceEvaluation(WHEN_ACTIVATED);
else
SetSalienceEvaluation(EVERY_CYCLE);
#endif
#if CONFLICT_RESOLUTION_STRATEGIES
/*--------------------------+
| Decode Strategy Combo Box |
+--------------------------*/
value = (int) SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_GETCURSEL, 0, 0);
SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_GETLBTEXT, value, (LONG)Msg );
if ( strcmp (Msg, "Depth" ) == 0 )
SetStrategy(DEPTH_STRATEGY);
else if (strcmp(Msg, "Breadth" ) == 0)
SetStrategy(BREADTH_STRATEGY);
else if (strcmp(Msg, "LEX") == 0 )
SetStrategy(LEX_STRATEGY);
else if (strcmp(Msg, "MEA") == 0 )
SetStrategy(MEA_STRATEGY);
else if (strcmp(Msg, "Complexity") == 0 )
SetStrategy(COMPLEXITY_STRATEGY);
else if (strcmp(Msg, "Simplicity") == 0 )
SetStrategy(SIMPLICITY_STRATEGY);
else
SetStrategy(RANDOM_STRATEGY);
#endif
/*-------------------------+
| Decode Other Check Boxes |
+-------------------------*/
SetStaticConstraintChecking ( IsDlgButtonChecked(hDlg, IDC_EXE_STATIC));
SetDynamicConstraintChecking ( IsDlgButtonChecked(hDlg, IDC_EXE_DYNAMIC));
SetAutoFloatDividend ( IsDlgButtonChecked(hDlg, IDC_EXE_AUTO));
#if DEFGLOBAL_CONSTRUCT
SetResetGlobals ( IsDlgButtonChecked(hDlg, IDC_EXE_GLOBAL));
#endif
#if DEFTEMPLATE_CONSTRUCT
SetFactDuplication( IsDlgButtonChecked(hDlg, IDC_EXE_FACT));
#endif
#if INCREMENTAL_RESET & (! RUN_TIME )
SetIncrementalReset ( IsDlgButtonChecked(hDlg, IDC_EXE_RESET));
#endif
#if ( ! RUN_TIME )
SetSequenceOperatorRecognition ( IsDlgButtonChecked(hDlg, IDC_EXE_SEQUENCE));
#endif
}
case IDC_CANCEL:
{ EndDialog( hDlg, IDOK);
return (TRUE);
}
/*-------------------+
| Toggle Check Boxes |
+-------------------*/
case IDC_EXE_RESET:
case IDC_EXE_STATIC:
case IDC_EXE_DYNAMIC:
case IDC_EXE_GLOBAL:
case IDC_EXE_FACT:
case IDC_EXE_AUTO:
case IDC_EXE_SEQUENCE:
{ SetCheckBox ( hDlg, wParam, !IsDlgButtonChecked (hDlg, wParam));
return (TRUE);
}
}
}
}
return (FALSE);
}
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);
}
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
}
