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 }