globle BOOLEAN DOsEqual(
DATA_OBJECT_PTR dobj1,
DATA_OBJECT_PTR dobj2)
{
if (GetpType(dobj1) != GetpType(dobj2))
{ return(FALSE); }
if (GetpType(dobj1) == MULTIFIELD)
{
if (MultifieldDOsEqual(dobj1,dobj2) == FALSE)
{ return(FALSE); }
}
else if (GetpValue(dobj1) != GetpValue(dobj2))
{ return(FALSE); }
return(TRUE);
}
/*******************************************************
NAME : EvaluateDeffunctionCall
DESCRIPTION : Primitive support function for
calling a deffunction
INPUTS : 1) The deffunction
2) A data object buffer to hold
the evaluation result
RETURNS : FALSE if the deffunction
returns the symbol FALSE,
TRUE otherwise
SIDE EFFECTS : Data obejct buffer set and any
side-effects of calling the deffunction
NOTES : None
*******************************************************/
static intBool EvaluateDeffunctionCall(
void *theEnv,
void *value,
DATA_OBJECT *result)
{
CallDeffunction(theEnv,(DEFFUNCTION *) value,GetFirstArgument(),result);
if ((GetpType(result) == SYMBOL) &&
(GetpValue(result) == EnvFalseSymbol(theEnv)))
return(FALSE);
return(TRUE);
}
globle struct expr *ConvertValueToExpression(
DATA_OBJECT *theValue)
{
long i;
struct expr *head = NULL, *last = NULL, *newItem;
if (GetpType(theValue) != MULTIFIELD)
{ return(GenConstant(GetpType(theValue),GetpValue(theValue))); }
for (i = GetpDOBegin(theValue); i <= GetpDOEnd(theValue); i++)
{
newItem = GenConstant(GetMFType(GetpValue(theValue),i),
GetMFValue(GetpValue(theValue),i));
if (last == NULL) head = newItem;
else last->nextArg = newItem;
last = newItem;
}
if (head == NULL)
return(GenConstant(FCALL,(void *) FindFunction("create$")));
return(head);
}
globle const char *DataObjectToString(
void *theEnv,
DATA_OBJECT *theDO)
{
void *thePtr;
const char *theString;
char *newString;
const char *prefix, *postfix;
size_t length;
struct externalAddressHashNode *theAddress;
char buffer[30];
switch (GetpType(theDO))
{
case MULTIFIELD:
prefix = "(";
theString = ValueToString(ImplodeMultifield(theEnv,theDO));
postfix = ")";
break;
case STRING:
prefix = "\"";
theString = DOPToString(theDO);
postfix = "\"";
break;
case INSTANCE_NAME:
prefix = "[";
theString = DOPToString(theDO);
postfix = "]";
break;
case SYMBOL:
return(DOPToString(theDO));
case FLOAT:
return(FloatToString(theEnv,DOPToDouble(theDO)));
case INTEGER:
return(LongIntegerToString(theEnv,DOPToLong(theDO)));
case RVOID:
return("");
#if OBJECT_SYSTEM
case INSTANCE_ADDRESS:
thePtr = DOPToPointer(theDO);
if (thePtr == (void *) &InstanceData(theEnv)->DummyInstance)
{ return("<Dummy Instance>"); }
if (((struct instance *) thePtr)->garbage)
{
prefix = "<Stale Instance-";
theString = ValueToString(((struct instance *) thePtr)->name);
postfix = ">";
}
else
{
prefix = "<Instance-";
theString = ValueToString(GetFullInstanceName(theEnv,(INSTANCE_TYPE *) thePtr));
postfix = ">";
}
break;
#endif
case EXTERNAL_ADDRESS:
theAddress = (struct externalAddressHashNode *) DOPToPointer(theDO);
/* TBD Need specific routine for creating name string. */
gensprintf(buffer,"<Pointer-%d-%p>",(int) theAddress->type,DOPToExternalAddress(theDO));
thePtr = EnvAddSymbol(theEnv,buffer);
return(ValueToString(thePtr));
#if DEFTEMPLATE_CONSTRUCT
case FACT_ADDRESS:
if (DOPToPointer(theDO) == (void *) &FactData(theEnv)->DummyFact)
{ return("<Dummy Fact>"); }
thePtr = DOPToPointer(theDO);
gensprintf(buffer,"<Fact-%lld>",((struct fact *) thePtr)->factIndex);
thePtr = EnvAddSymbol(theEnv,buffer);
return(ValueToString(thePtr));
#endif
default:
return("UNK");
}
length = strlen(prefix) + strlen(theString) + strlen(postfix) + 1;
newString = (char *) genalloc(theEnv,length);
newString[0] = '\0';
genstrcat(newString,prefix);
genstrcat(newString,theString);
genstrcat(newString,postfix);
thePtr = EnvAddSymbol(theEnv,newString);
genfree(theEnv,newString,length);
return(ValueToString(thePtr));
}
void *GetFactOrInstanceArgument(
void *theEnv,
int thePosition,
DATA_OBJECT *item,
char *functionName)
{
#if DEFTEMPLATE_CONSTRUCT || OBJECT_SYSTEM
void *ptr;
#endif
/*==============================*/
/* Retrieve the first argument. */
/*==============================*/
EnvRtnUnknown(theEnv,thePosition,item);
/*==================================================*/
/* Fact and instance addresses are valid arguments. */
/*==================================================*/
if ((GetpType(item) == FACT_ADDRESS) ||
(GetpType(item) == INSTANCE_ADDRESS))
{ return(GetpValue(item)); }
/*==================================================*/
/* An integer is a valid argument if it corresponds */
/* to the fact index of an existing fact. */
/*==================================================*/
#if DEFTEMPLATE_CONSTRUCT
else if (GetpType(item) == INTEGER)
{
if ((ptr = (void *) FindIndexedFact(theEnv,DOPToLong(item))) == NULL)
{
char tempBuffer[20];
sprintf(tempBuffer,"f-%ld",DOPToLong(item));
CantFindItemErrorMessage(theEnv,"fact",tempBuffer);
}
return(ptr);
}
#endif
/*================================================*/
/* Instance names and symbols are valid arguments */
/* if they correspond to an existing instance. */
/*================================================*/
#if OBJECT_SYSTEM
else if ((GetpType(item) == INSTANCE_NAME) || (GetpType(item) == SYMBOL))
{
if ((ptr = (void *) FindInstanceBySymbol(theEnv,(SYMBOL_HN *) GetpValue(item))) == NULL)
{
CantFindItemErrorMessage(theEnv,"instance",ValueToString(GetpValue(item)));
}
return(ptr);
}
#endif
/*========================================*/
/* Any other type is an invalid argument. */
/*========================================*/
ExpectedTypeError2(theEnv,functionName,thePosition);
return(NULL);
}
globle void StoreInMultifield(
void *theEnv,
DATA_OBJECT *returnValue,
EXPRESSION *expptr,
int garbageSegment)
{
DATA_OBJECT val_ptr;
DATA_OBJECT *val_arr;
struct multifield *theMultifield;
struct multifield *orig_ptr;
long start, end, i,j, k, argCount;
unsigned long seg_size;
argCount = CountArguments(expptr);
/*=========================================*/
/* If no arguments are given return a NULL */
/* multifield of length zero. */
/*=========================================*/
if (argCount == 0)
{
SetpType(returnValue,MULTIFIELD);
SetpDOBegin(returnValue,1);
SetpDOEnd(returnValue,0);
if (garbageSegment) theMultifield = (struct multifield *) EnvCreateMultifield(theEnv,0L);
else theMultifield = (struct multifield *) CreateMultifield2(theEnv,0L);
SetpValue(returnValue,(void *) theMultifield);
return;
}
else
{
/*========================================*/
/* Get a new segment with length equal to */
/* the total length of all the arguments. */
/*========================================*/
val_arr = (DATA_OBJECT *) gm3(theEnv,(long) sizeof(DATA_OBJECT) * argCount);
seg_size = 0;
for (i = 1; i <= argCount; i++, expptr = expptr->nextArg)
{
EvaluateExpression(theEnv,expptr,&val_ptr);
if (EvaluationData(theEnv)->EvaluationError)
{
SetpType(returnValue,MULTIFIELD);
SetpDOBegin(returnValue,1);
SetpDOEnd(returnValue,0);
if (garbageSegment)
{ theMultifield = (struct multifield *) EnvCreateMultifield(theEnv,0L); }
else theMultifield = (struct multifield *) CreateMultifield2(theEnv,0L);
SetpValue(returnValue,(void *) theMultifield);
rm3(theEnv,val_arr,(long) sizeof(DATA_OBJECT) * argCount);
return;
}
SetpType(val_arr+i-1,GetType(val_ptr));
if (GetType(val_ptr) == MULTIFIELD)
{
SetpValue(val_arr+i-1,GetpValue(&val_ptr));
start = GetDOBegin(val_ptr);
end = GetDOEnd(val_ptr);
}
else if (GetType(val_ptr) == RVOID)
{
SetpValue(val_arr+i-1,GetValue(val_ptr));
start = 1;
end = 0;
}
else
{
SetpValue(val_arr+i-1,GetValue(val_ptr));
start = end = -1;
}
seg_size += (unsigned long) (end - start + 1);
SetpDOBegin(val_arr+i-1,start);
SetpDOEnd(val_arr+i-1,end);
}
if (garbageSegment)
{ theMultifield = (struct multifield *) EnvCreateMultifield(theEnv,seg_size); }
else theMultifield = (struct multifield *) CreateMultifield2(theEnv,seg_size);
/*========================================*/
/* Copy each argument into new segment. */
/*========================================*/
for (k = 0, j = 1; k < argCount; k++)
{
if (GetpType(val_arr+k) == MULTIFIELD)
{
start = GetpDOBegin(val_arr+k);
end = GetpDOEnd(val_arr+k);
orig_ptr = (struct multifield *) GetpValue(val_arr+k);
for (i = start; i < end + 1; i++, j++)
{
SetMFType(theMultifield,j,(GetMFType(orig_ptr,i)));
SetMFValue(theMultifield,j,(GetMFValue(orig_ptr,i)));
}
}
else if (GetpType(val_arr+k) != RVOID)
{
SetMFType(theMultifield,j,(short) (GetpType(val_arr+k)));
SetMFValue(theMultifield,j,(GetpValue(val_arr+k)));
j++;
}
}
/*=========================*/
/* Return the new segment. */
/*=========================*/
SetpType(returnValue,MULTIFIELD);
SetpDOBegin(returnValue,1);
SetpDOEnd(returnValue,(long) seg_size);
SetpValue(returnValue,(void *) theMultifield);
rm3(theEnv,val_arr,(long) sizeof(DATA_OBJECT) * argCount);
return;
}
}
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
}