globle void ShowFactPatternNetwork( void *theEnv) { struct factPatternNode *patternPtr; struct deftemplate *theDeftemplate; const char *theName; int depth = 0, i; theName = GetConstructName(theEnv,"show-fpn","template name"); if (theName == NULL) return; theDeftemplate = (struct deftemplate *) EnvFindDeftemplate(theEnv,theName); if (theDeftemplate == NULL) return; patternPtr = theDeftemplate->patternNetwork; while (patternPtr != NULL) { for (i = 0; i < depth; i++) EnvPrintRouter(theEnv,WDISPLAY," "); if (patternPtr->header.singlefieldNode) EnvPrintRouter(theEnv,WDISPLAY,"SF "); else if (patternPtr->header.multifieldNode) { EnvPrintRouter(theEnv,WDISPLAY,"MF"); if (patternPtr->header.endSlot) EnvPrintRouter(theEnv,WDISPLAY,")"); else EnvPrintRouter(theEnv,WDISPLAY,"*"); PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->leaveFields); EnvPrintRouter(theEnv,WDISPLAY," "); } EnvPrintRouter(theEnv,WDISPLAY,"Slot: "); PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->whichSlot); EnvPrintRouter(theEnv,WDISPLAY," Field: "); PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->whichField); EnvPrintRouter(theEnv,WDISPLAY," Expression: "); if (patternPtr->networkTest == NULL) EnvPrintRouter(theEnv,WDISPLAY,"None"); else PrintExpression(theEnv,WDISPLAY,patternPtr->networkTest); EnvPrintRouter(theEnv,WDISPLAY," RightHash: "); if (patternPtr->header.rightHash == NULL) EnvPrintRouter(theEnv,WDISPLAY,"None"); else PrintExpression(theEnv,WDISPLAY,patternPtr->header.rightHash); EnvPrintRouter(theEnv,WDISPLAY,"\n"); if (patternPtr->nextLevel == NULL) { while (patternPtr->rightNode == NULL) { patternPtr = patternPtr->lastLevel; depth--; if (patternPtr == NULL) return; } patternPtr = patternPtr->rightNode; } else { patternPtr = patternPtr->nextLevel; depth++; } } }
static void ClearDeffacts( void *theEnv) { #if (! RUN_TIME) && (! BLOAD_ONLY) struct expr *stub; struct deffacts *newDeffacts; /*=====================================*/ /* Create the data structures for the */ /* expression (assert (initial-fact)). */ /*=====================================*/ stub = GenConstant(theEnv,FCALL,FindFunction(theEnv,"assert")); stub->argList = GenConstant(theEnv,DEFTEMPLATE_PTR,EnvFindDeftemplate(theEnv,"initial-fact")); ExpressionInstall(theEnv,stub); /*=============================================*/ /* Create a deffacts data structure to contain */ /* the expression and initialize it. */ /*=============================================*/ newDeffacts = get_struct(theEnv,deffacts); newDeffacts->header.whichModule = (struct defmoduleItemHeader *) GetDeffactsModuleItem(theEnv,NULL); newDeffacts->header.name = (SYMBOL_HN *) EnvAddSymbol(theEnv,"initial-fact"); IncrementSymbolCount(newDeffacts->header.name); newDeffacts->assertList = PackExpression(theEnv,stub); newDeffacts->header.next = NULL; newDeffacts->header.ppForm = NULL; newDeffacts->header.usrData = NULL; ReturnExpression(theEnv,stub); /*===========================================*/ /* Store the deffacts in the current module. */ /*===========================================*/ AddConstructToModule(&newDeffacts->header); #else #if MAC_MCW || WIN_MCW || MAC_XCD #pragma unused(theEnv) #endif #endif }
void *entryPoint(void * m_theEnv) { void *newFact; void *templatePtr; void *theMultifield; DATA_OBJECT theValue; char *templatename = "InputSource"; /* Create the fact. */ /*==================*/ templatePtr = EnvFindDeftemplate(m_theEnv,templatename); newFact = EnvCreateFact(m_theEnv,templatePtr); if (newFact == NULL) return 0; theValue.type = INTEGER; theValue.value = EnvAddLong(m_theEnv,100); EnvPutFactSlot(m_theEnv,newFact,"speed",&theValue); theValue.type = FLOAT; theValue.value = EnvAddDouble(m_theEnv,1.0); EnvPutFactSlot(m_theEnv,newFact,"astatus",&theValue); theValue.type = INTEGER; theValue.value = EnvAddLong(m_theEnv,2); EnvPutFactSlot(m_theEnv,newFact,"rclass",&theValue); theValue.type = INTEGER; theValue.value = EnvAddLong(m_theEnv,10000); EnvPutFactSlot(m_theEnv,newFact,"distance",&theValue); EnvAssignFactSlotDefaults(m_theEnv,newFact); EnvAssert(m_theEnv,newFact); return newFact; }
static DATA_OBJECT_PTR GetSaveFactsDeftemplateNames( void *theEnv, struct expr *theList, int saveCode, int *count, int *error) { struct expr *tempList; DATA_OBJECT_PTR theDOArray; int i, tempCount; struct deftemplate *theDeftemplate = NULL; /*=============================*/ /* Initialize the error state. */ /*=============================*/ *error = FALSE; /*=====================================================*/ /* If no deftemplate names were specified as arguments */ /* then the deftemplate name list is empty. */ /*=====================================================*/ if (theList == NULL) { *count = 0; return(NULL); } /*======================================*/ /* Determine the number of deftemplate */ /* names to be stored in the name list. */ /*======================================*/ for (tempList = theList, *count = 0; tempList != NULL; tempList = tempList->nextArg, (*count)++) { /* Do Nothing */ } /*=========================================*/ /* Allocate the storage for the name list. */ /*=========================================*/ theDOArray = (DATA_OBJECT_PTR) gm3(theEnv,(long) sizeof(DATA_OBJECT) * *count); /*=====================================*/ /* Loop through each of the arguments. */ /*=====================================*/ for (tempList = theList, i = 0; i < *count; tempList = tempList->nextArg, i++) { /*========================*/ /* Evaluate the argument. */ /*========================*/ EvaluateExpression(theEnv,tempList,&theDOArray[i]); if (EvaluationData(theEnv)->EvaluationError) { *error = TRUE; rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count); return(NULL); } /*======================================*/ /* A deftemplate name must be a symbol. */ /*======================================*/ if (theDOArray[i].type != SYMBOL) { *error = TRUE; ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"symbol"); rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count); return(NULL); } /*===================================================*/ /* Find the deftemplate. For a local save, look only */ /* in the current module. For a visible save, look */ /* in all visible modules. */ /*===================================================*/ if (saveCode == LOCAL_SAVE) { theDeftemplate = (struct deftemplate *) EnvFindDeftemplate(theEnv,ValueToString(theDOArray[i].value)); if (theDeftemplate == NULL) { *error = TRUE; ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"local deftemplate name"); rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count); return(NULL); } } else if (saveCode == VISIBLE_SAVE) { theDeftemplate = (struct deftemplate *) FindImportedConstruct(theEnv,(char*)"deftemplate",NULL, ValueToString(theDOArray[i].value), &tempCount,TRUE,NULL); if (theDeftemplate == NULL) { *error = TRUE; ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"visible deftemplate name"); rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count); return(NULL); } } /*==================================*/ /* Add a pointer to the deftemplate */ /* to the array being created. */ /*==================================*/ theDOArray[i].type = DEFTEMPLATE_PTR; theDOArray[i].value = (void *) theDeftemplate; } /*===================================*/ /* Return the array of deftemplates. */ /*===================================*/ return(theDOArray); }
void ClipsRuleMgr::getTemplateFields() { void *templatePtr; DATA_OBJECT theValue; void *theMultifield; DATA_OBJECT theValueOfType; void *theMultifieldOfType; int cnt1 = 0; int i = 1; int fieldType; void *fieldValue; m_templateItor = m_templateNames.begin(); while(m_templateItor!=m_templateNames.end()) { cout<<"Rule Engine IntializeStream::m_templateNames:" <<*m_templateItor<<endl; templatePtr = EnvFindDeftemplate(m_theEnv,(*m_templateItor).c_str()); EnvDeftemplateSlotNames(m_theEnv, templatePtr, &theValue); if (GetpType(&theValue) == MULTIFIELD) { cnt1 = GetpDOLength(&theValue); //theMultifield = theValue.value; theMultifield=GetValue(theValue); vector<Field> fields; for (i=1; i<=cnt1; i++) { fieldType = GetMFType(theMultifield,i); if (fieldType == SYMBOL) { Field tmp; fieldValue = (void*)ValueToString(GetMFValue(theMultifield,i)); tmp.name = string((char*)fieldValue); tmp.type = 2; EnvDeftemplateSlotTypes(m_theEnv,templatePtr,(char *)fieldValue, &theValueOfType); if (GetpType(&theValueOfType) == MULTIFIELD) { GetpDOLength(&theValueOfType); theMultifieldOfType = theValueOfType.value; ///default contraict to first one fieldType = GetMFType(theMultifieldOfType,1); if (fieldType == SYMBOL) { fieldValue = GetMFValue(theMultifieldOfType,1); if (string(ValueToString(fieldValue)) == string("FLOAT")) { tmp.type = 0; } else if (string(ValueToString(fieldValue)) == string("INTEGER")) { tmp.type = 1; } else { tmp.type = 2; } } else { cout<<"Rule Engine IntializeStream::EnvDeftemplateSlotTypes get unknown field type when get slot type:" <<fieldType<<endl; } } fields.push_back(tmp); } else { cout<<"Rule Engine IntializeStream::get unknown field type when get slot name:" <<fieldType<<endl; } } tableSchema.insert(pair<string, vector<Field> >(*m_templateItor, fields)); } else { cout<<"Rule Engine IntializeStream:::EnvDeftemplateSlotNames return not multifiled" <<endl; } m_templateItor++; } //call streaming interface to set tableSchema here }
globle void *FindDeftemplate( const char *deftemplateName) { return EnvFindDeftemplate(GetCurrentEnvironment(),deftemplateName); }