/***************************************************
NAME : UpdateDefclassesScope
DESCRIPTION : This function updates the scope
bitmaps for existing classes when
a new module is defined
INPUTS : None
RETURNS : Nothing
SIDE EFFECTS : Class scope bitmaps are updated
NOTES : None
***************************************************/
static void UpdateDefclassesScope(
void *theEnv)
{
register unsigned i;
DEFCLASS *theDefclass;
int newModuleID,count;
char *newScopeMap;
unsigned newScopeMapSize;
char *className;
struct defmodule *matchModule;
newModuleID = (int) ((struct defmodule *) EnvGetCurrentModule(theEnv))->bsaveID;
newScopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
newScopeMap = (char *) gm2(theEnv,newScopeMapSize);
for (i = 0 ; i < CLASS_TABLE_HASH_SIZE ; i++)
for (theDefclass = DefclassData(theEnv)->ClassTable[i] ;
theDefclass != NULL ;
theDefclass = theDefclass->nxtHash)
{
matchModule = theDefclass->header.whichModule->theModule;
className = ValueToString(theDefclass->header.name);
ClearBitString((void *) newScopeMap,newScopeMapSize);
GenCopyMemory(char,theDefclass->scopeMap->size,
newScopeMap,ValueToBitMap(theDefclass->scopeMap));
DecrementBitMapCount(theEnv,theDefclass->scopeMap);
if (theDefclass->system)
SetBitMap(newScopeMap,newModuleID);
else if (FindImportedConstruct(theEnv,(char*)"defclass",matchModule,
className,&count,TRUE,NULL) != NULL)
SetBitMap(newScopeMap,newModuleID);
theDefclass->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) newScopeMap,newScopeMapSize);
IncrementBitMapCount(theDefclass->scopeMap);
}
rm(theEnv,(void *) newScopeMap,newScopeMapSize);
}
/****************************************************
NAME : GenObjectLengthTest
DESCRIPTION : Generates a test on the cardinality
of a slot matching an object pattern
INPUTS : The first lhsParseNode for a slot
in an object pattern
RETURNS : Nothing useful
SIDE EFFECTS : The lhsParseNode network test is
modified to include the length test
NOTES : None
****************************************************/
globle void GenObjectLengthTest(
void *theEnv,
struct lhsParseNode *theNode)
{
struct ObjectMatchLength hack;
EXPRESSION *theTest;
if ((theNode->singleFieldsAfter == 0) &&
(theNode->type != SF_VARIABLE) &&
(theNode->type != SF_WILDCARD))
return;
ClearBitString((void *) &hack,(int) sizeof(struct ObjectMatchLength));
if ((theNode->type != MF_VARIABLE) &&
(theNode->type != MF_WILDCARD) &&
(theNode->multiFieldsAfter == 0))
hack.exactly = 1;
else
hack.exactly = 0;
if ((theNode->type == SF_VARIABLE) || (theNode->type == SF_WILDCARD))
hack.minLength = 1 + theNode->singleFieldsAfter;
else
hack.minLength = theNode->singleFieldsAfter;
theTest = GenConstant(theEnv,OBJ_SLOT_LENGTH,EnvAddBitMap(theEnv,(void *) &hack,
(int) sizeof(struct ObjectMatchLength)));
if (theNode->constantSelector != NULL)
{ theNode->constantSelector->nextArg = CopyExpression(theEnv,theTest); }
theNode->networkTest = CombineExpressions(theEnv,theTest,theNode->networkTest);
}
static void *FactGetVarJN2(
struct lhsParseNode *theNode)
{
struct factGetVarJN2Call hack;
/*===================================================*/
/* Clear the bitmap for storing the argument values. */
/*===================================================*/
ClearBitString(&hack,sizeof(struct factGetVarJN2Call));
/*=====================================================*/
/* Store the position in the partial match from which */
/* the fact will be retrieved and the slot in the fact */
/* from which the value will be retrieved. */
/*=====================================================*/
hack.whichSlot = theNode->slotNumber - 1;
hack.whichPattern = theNode->pattern - 1;
/*=============================*/
/* Return the argument bitmap. */
/*=============================*/
return(AddBitMap(&hack,sizeof(struct factGetVarJN2Call)));
}
globle void *CreateDeftemplateScopeMap(
void *theEnv,
struct deftemplate *theDeftemplate)
{
unsigned scopeMapSize;
char *scopeMap;
char *templateName;
struct defmodule *matchModule, *theModule;
int moduleID,count;
void *theBitMap;
templateName = ValueToString(theDeftemplate->header.name);
matchModule = theDeftemplate->header.whichModule->theModule;
scopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
scopeMap = (char *) gm2(theEnv,scopeMapSize);
ClearBitString((void *) scopeMap,scopeMapSize);
SaveCurrentModule(theEnv);
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL) ;
theModule != NULL ;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleID = (int) theModule->bsaveID;
if (FindImportedConstruct(theEnv,"deftemplate",matchModule,
templateName,&count,TRUE,NULL) != NULL)
SetBitMap(scopeMap,moduleID);
}
RestoreCurrentModule(theEnv);
theBitMap = EnvAddBitMap(theEnv,scopeMap,scopeMapSize);
IncrementBitMapCount(theBitMap);
rm(theEnv,(void *) scopeMap,scopeMapSize);
return(theBitMap);
}
static void *FactGetVarPN1(
struct lhsParseNode *theNode)
{
struct factGetVarPN1Call hack;
/*===================================================*/
/* Clear the bitmap for storing the argument values. */
/*===================================================*/
ClearBitString(&hack,sizeof(struct factGetVarPN1Call));
/*========================================*/
/* A slot value of zero indicates that we */
/* want the pattern address returned. */
/*========================================*/
if (theNode->slotNumber <= 0)
{
hack.factAddress = 1;
hack.allFields = 0;
hack.whichSlot = 0;
hack.whichField = 0;
}
/*=====================================================*/
/* A slot value greater than zero and a field value of */
/* zero indicate that we want the entire contents of */
/* the slot whether it is a single field or multifield */
/* slot. */
/*=====================================================*/
else if (theNode->index <= 0)
{
hack.factAddress = 0;
hack.allFields = 1;
hack.whichSlot = theNode->slotNumber - 1;
hack.whichField = 0;
}
/*=============================================*/
/* A slot value, m, and a field value, n, both */
/* greater than zero indicate that we want the */
/* nth field of the mth slot. */
/*=============================================*/
else
{
hack.factAddress = 0;
hack.allFields = 0;
hack.whichSlot = theNode->slotNumber - 1;
hack.whichField = theNode->index - 1;
}
/*=============================*/
/* Return the argument bitmap. */
/*=============================*/
return(AddBitMap(&hack,sizeof(struct factGetVarPN1Call)));
}
/**********************************************
Build functions used by AddPatternParser() to
provide object access to the pattern network
**********************************************/
globle EXPRESSION *GenObjectPNConstantCompare(
void *theEnv,
struct lhsParseNode *theNode)
{
struct ObjectCmpPNConstant hack;
EXPRESSION *theExp;
unsigned short tmpType;
/* ===============================================================
If the value of a single field slot (or relation name) is being
compared against a constant, then use specialized routines for
doing the comparison.
If a constant comparison is being done within a multifield slot
and the constant's position has no multifields to the left or
no multifields to the right, then use the same routine used for
the single field slot case, but include the offset from either
the beginning or end of the slot.
Otherwise, use a general eq/neq test.
=============================================================== */
ClearBitString((void *) &hack,(int) sizeof(struct ObjectCmpPNConstant));
if (theNode->negated)
hack.fail = 1;
else
hack.pass = 1;
if (((theNode->withinMultifieldSlot == FALSE) ||
(theNode->multiFieldsAfter == 0) ||
(theNode->multiFieldsBefore == 0)) &&
(theNode->slotNumber != ISA_ID) && (theNode->slotNumber != NAME_ID))
{
if (theNode->withinMultifieldSlot == FALSE)
hack.fromBeginning = TRUE;
else if (theNode->multiFieldsBefore == 0)
{
hack.fromBeginning = TRUE;
hack.offset = theNode->singleFieldsBefore;
}
else
hack.offset = theNode->singleFieldsAfter;
theExp = GenConstant(theEnv,OBJ_PN_CONSTANT,EnvAddBitMap(theEnv,(void *) &hack,
(int) sizeof(struct ObjectCmpPNConstant)));
theExp->argList = GenConstant(theEnv,theNode->type,theNode->value);
}
else
{
hack.general = 1;
theExp = GenConstant(theEnv,OBJ_PN_CONSTANT,EnvAddBitMap(theEnv,(void *) &hack,
(int) sizeof(struct ObjectCmpPNConstant)));
theExp->argList = GenConstant(theEnv,0,NULL);
tmpType = theNode->type;
theNode->type = SF_VARIABLE;
GenObjectGetVar(theEnv,FALSE,theExp->argList,theNode,-1);
theNode->type = tmpType;
theExp->argList->nextArg = GenConstant(theEnv,theNode->type,theNode->value);
}
return(theExp);
}
globle struct expr *FactPNVariableComparison(
struct lhsParseNode *selfNode,
struct lhsParseNode *referringNode)
{
struct expr *top;
struct factCompVarsPN1Call hack;
/*===================================================*/
/* Clear the bitmap for storing the argument values. */
/*===================================================*/
ClearBitString(&hack,sizeof(struct factCompVarsPN1Call));
/*================================================================*/
/* If two single field slots of a deftemplate are being compared, */
/* then use the following specified variable comparison routine. */
/*================================================================*/
if ((selfNode->withinMultifieldSlot == FALSE) &&
(selfNode->slotNumber > 0) &&
(referringNode->withinMultifieldSlot == FALSE) &&
(referringNode->slotNumber > 0))
{
hack.pass = 0;
hack.fail = 0;
hack.field1 = (unsigned int) selfNode->slotNumber - 1;
hack.field2 = (unsigned int) referringNode->slotNumber - 1;
if (selfNode->negated) hack.fail = 1;
else hack.pass = 1;
top = GenConstant(FACT_PN_CMP1,AddBitMap(&hack,sizeof(struct factCompVarsPN1Call)));
}
/*================================================================*/
/* Otherwise, use the eq function to compare the values retrieved */
/* by the appropriate get variable value functions. */
/*================================================================*/
else
{
if (selfNode->negated) top = GenConstant(FCALL,PTR_NEQ);
else top = GenConstant(FCALL,PTR_EQ);
top->argList = FactGenGetfield(selfNode);
top->argList->nextArg = FactGenGetfield(referringNode);
}
/*======================================*/
/* Return the expression for performing */
/* the variable comparison. */
/*======================================*/
return(top);
}
/****************************************************
NAME : GenObjectZeroLengthTest
DESCRIPTION : Generates a test on the cardinality
of a slot matching an object pattern
INPUTS : The first lhsParseNode for a slot
in an object pattern
RETURNS : Nothing useful
SIDE EFFECTS : The lhsParseNode network test is
modified to include the length test
NOTES : None
****************************************************/
globle void GenObjectZeroLengthTest(
struct lhsParseNode *theNode)
{
struct ObjectMatchLength hack;
EXPRESSION *theTest;
ClearBitString((void *) &hack,(int) sizeof(struct ObjectMatchLength));
hack.exactly = 1;
hack.minLength = 0;
theTest = GenConstant(OBJ_SLOT_LENGTH,AddBitMap((void *) &hack,
(int) sizeof(struct ObjectMatchLength)));
theNode->networkTest = CombineExpressions(theTest,theNode->networkTest);
}
globle struct expr *FactGenCheckZeroLength(
int theSlot)
{
struct factCheckLengthPNCall hack;
ClearBitString(&hack,sizeof(struct factCheckLengthPNCall));
hack.whichSlot = theSlot-1;
hack.exactly = 1;
hack.minLength = 0;
return(GenConstant(FACT_SLOT_LENGTH,AddBitMap(&hack,sizeof(struct factCheckLengthPNCall))));
}
globle struct expr *FactGenCheckLength(
struct lhsParseNode *theNode)
{
struct factCheckLengthPNCall hack;
/*===================================================*/
/* If the slot contains no single field constraints, */
/* then a length test is not necessary. */
/*===================================================*/
if ((theNode->singleFieldsAfter == 0) &&
(theNode->type != SF_VARIABLE) &&
(theNode->type != SF_WILDCARD))
{ return(NULL); }
/*=======================================*/
/* Initialize the length test arguments. */
/*=======================================*/
ClearBitString(&hack,sizeof(struct factCheckLengthPNCall));
hack.whichSlot = theNode->slotNumber - 1;
/*============================================*/
/* If the slot has no multifield constraints, */
/* then the length must match exactly. */
/*============================================*/
if ((theNode->type != MF_VARIABLE) &&
(theNode->type != MF_WILDCARD) &&
(theNode->multiFieldsAfter == 0))
{ hack.exactly = 1; }
else
{ hack.exactly = 0; }
/*============================================*/
/* The minimum length is the number of single */
/* field constraints contained in the slot. */
/*============================================*/
if ((theNode->type == SF_VARIABLE) || (theNode->type == SF_WILDCARD))
{ hack.minLength = 1 + theNode->singleFieldsAfter; }
else
{ hack.minLength = theNode->singleFieldsAfter; }
/*========================================================*/
/* Generate call to test the length of a multifield slot. */
/*========================================================*/
return(GenConstant(FACT_SLOT_LENGTH,AddBitMap(&hack,sizeof(struct factCheckLengthPNCall))));
}
/***************************************************
NAME : GenHandlerSlotReference
DESCRIPTION : Creates a bitmap of the class id
and slot index for the get or put
operation. The bitmap and operation
type are stored in the given
expression.
INPUTS : 1) The expression
2) The operation type
3) The class slot
RETURNS : Nothing useful
SIDE EFFECTS : Bitmap created and expression
initialized
NOTES : None
***************************************************/
static void GenHandlerSlotReference(
void *theEnv,
EXPRESSION *theExp,
unsigned short theType,
SLOT_DESC *sd)
{
HANDLER_SLOT_REFERENCE handlerReference;
ClearBitString(&handlerReference,sizeof(HANDLER_SLOT_REFERENCE));
handlerReference.classID = (unsigned short) sd->cls->id;
handlerReference.slotID = (unsigned) sd->slotName->id;
theExp->type = theType;
theExp->value = AddBitMap(theEnv,(void *) &handlerReference,
(int) sizeof(HANDLER_SLOT_REFERENCE));
}
/*********************************************************
NAME : AddSystemClass
DESCRIPTION : Performs all necessary allocations
for adding a system class
INPUTS : 1) The name-string of the system class
2) The address of the parent class
(NULL if none)
RETURNS : The address of the new system class
SIDE EFFECTS : Allocations performed
NOTES : Assumes system-class name is unique
Also assumes SINGLE INHERITANCE for
system classes to simplify precedence
list determination
Adds classes to has table but NOT to
class list (this is responsibility
of caller)
*********************************************************/
static DEFCLASS *AddSystemClass(
void *theEnv,
char *name,
DEFCLASS *parent)
{
DEFCLASS *sys;
long i;
char defaultScopeMap[1];
sys = NewClass(theEnv,(SYMBOL_HN *) EnvAddSymbol(theEnv,name));
sys->abstract = 1;
#if DEFRULE_CONSTRUCT
sys->reactive = 0;
#endif
IncrementSymbolCount(sys->header.name);
sys->installed = 1;
sys->system = 1;
sys->hashTableIndex = HashClass(sys->header.name);
AddClassLink(theEnv,&sys->allSuperclasses,sys,-1);
if (parent != NULL)
{
AddClassLink(theEnv,&sys->directSuperclasses,parent,-1);
AddClassLink(theEnv,&parent->directSubclasses,sys,-1);
AddClassLink(theEnv,&sys->allSuperclasses,parent,-1);
for (i = 1 ; i < parent->allSuperclasses.classCount ; i++)
AddClassLink(theEnv,&sys->allSuperclasses,parent->allSuperclasses.classArray[i],-1);
}
sys->nxtHash = DefclassData(theEnv)->ClassTable[sys->hashTableIndex];
DefclassData(theEnv)->ClassTable[sys->hashTableIndex] = sys;
/* =========================================
Add default scope maps for a system class
There is only one module (MAIN) so far -
which has an id of 0
========================================= */
ClearBitString((void *) defaultScopeMap,(int) sizeof(char));
SetBitMap(defaultScopeMap,0);
#if DEFMODULE_CONSTRUCT
sys->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) defaultScopeMap,(int) sizeof(char));
IncrementBitMapCount(sys->scopeMap);
#endif
return(sys);
}
static void *FactGetVarPN2(
struct lhsParseNode *theNode)
{
struct factGetVarPN2Call hack;
/*===================================================*/
/* Clear the bitmap for storing the argument values. */
/*===================================================*/
ClearBitString(&hack,sizeof(struct factGetVarPN2Call));
/*=======================================*/
/* Store the slot in the fact from which */
/* the value will be retrieved. */
/*=======================================*/
hack.whichSlot = theNode->slotNumber - 1;
/*=============================*/
/* Return the argument bitmap. */
/*=============================*/
return(AddBitMap(&hack,sizeof(struct factGetVarPN2Call)));
}
/***************************************************************
NAME : GenerateSlotComparisonTest
DESCRIPTION : Generates pattern and join network
expressions for comparing object
pattern variables
INPUTS : 1) A flag indicating if this is a
pattern or join network test
2) For a join test, a flag indicating
if it is a nand join
3) The intermediate parse node
for the first variable
4) The intermediate parse node
for the second variable
RETURNS : An expression for comparing the
variables
SIDE EFFECTS : Expression and bitmaps generated
NOTES : The following tests are generated
for the following scenarios:
SF slot w/ SF slot: PN_1 or JN_1
Example: (foo ?x) with (bar ?xy)
SF slot w/ SF reference in MF slot: PN_2 or JN_2
Example: (foo ?x) (bar ? ?x ? ?)
SF reference w/ SF reference: PN_3 or JN_3
Example: (foo ? ?x ?) and (bar ? ? ? ?x)
All other cases: EQ/NEQ general test
Example: (foo $? ?x $?) and (bar ?x)
***************************************************************/
static EXPRESSION *GenerateSlotComparisonTest(
void *theEnv,
int joinTest,
int isNand,
struct lhsParseNode *selfNode,
struct lhsParseNode *referringNode)
{
EXPRESSION *theExp;
struct ObjectCmpPNSingleSlotVars1 phack1;
struct ObjectCmpPNSingleSlotVars2 phack2;
struct ObjectCmpPNSingleSlotVars3 phack3;
struct ObjectCmpJoinSingleSlotVars1 jhack1;
struct ObjectCmpJoinSingleSlotVars2 jhack2;
struct ObjectCmpJoinSingleSlotVars3 jhack3;
struct lhsParseNode *firstNode;
if (isNand)
{ firstNode = referringNode; }
else
{ firstNode = selfNode; }
/* =========================================================
If we are comparing two single-field slot variables that
don't require multifield markers for lookup, use
a quick comparison. Otherwise, use a general eq/neq with
the pattern variable access routines
========================================================= */
if (IsSimpleSlotVariable(firstNode) && IsSimpleSlotVariable(referringNode))
{
/* ==============================
Compare two single-field slots
============================== */
if ((firstNode->withinMultifieldSlot == FALSE) &&
(referringNode->withinMultifieldSlot == FALSE))
{
ClearBitString((void *) &phack1,(int) sizeof(struct ObjectCmpPNSingleSlotVars1));
ClearBitString((void *) &jhack1,(int) sizeof(struct ObjectCmpJoinSingleSlotVars1));
if (selfNode->negated)
phack1.fail = jhack1.fail = 1;
else
phack1.pass = jhack1.pass = 1;
phack1.firstSlot = jhack1.firstSlot = (unsigned short) firstNode->slotNumber;
phack1.secondSlot = jhack1.secondSlot = (unsigned short) referringNode->slotNumber;
if (joinTest)
{
if (isNand)
{ jhack1.firstPattern = (unsigned short) referringNode->joinDepth; }
else
{ jhack1.firstPattern = 0; }
jhack1.firstPatternRHS = TRUE;
jhack1.secondPatternLHS = TRUE;
jhack1.secondPattern = (unsigned short) referringNode->joinDepth;
theExp = GenConstant(theEnv,OBJ_JN_CMP1,EnvAddBitMap(theEnv,(void *) &jhack1,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars1)));
}
else
theExp = GenConstant(theEnv,OBJ_PN_CMP1,EnvAddBitMap(theEnv,(void *) &phack1,
(int) sizeof(struct ObjectCmpPNSingleSlotVars1)));
}
/* ============================================
Compare a single-field slot with a
single-field in a multifield slot (make sure
the multifield slot reference is first
============================================ */
else if ((firstNode->withinMultifieldSlot == FALSE) ||
(referringNode->withinMultifieldSlot == FALSE))
{
ClearBitString((void *) &phack2,(int) sizeof(struct ObjectCmpPNSingleSlotVars2));
ClearBitString((void *) &jhack2,(int) sizeof(struct ObjectCmpJoinSingleSlotVars2));
if (selfNode->negated)
phack2.fail = jhack2.fail = 1;
else
phack2.pass = jhack2.pass = 1;
if (firstNode->withinMultifieldSlot == TRUE)
{
phack2.firstSlot = jhack2.firstSlot = (unsigned short) firstNode->slotNumber;
phack2.secondSlot = jhack2.secondSlot = (unsigned short) referringNode->slotNumber;
if (joinTest)
{
if (isNand)
{ jhack2.firstPattern = (unsigned short) referringNode->joinDepth; }
else
{ jhack2.firstPattern = 0; }
jhack2.firstPatternRHS = TRUE;
jhack2.secondPatternLHS = TRUE;
jhack2.secondPattern = (unsigned short) referringNode->joinDepth;
}
if (firstNode->multiFieldsBefore == 0)
{
phack2.fromBeginning = jhack2.fromBeginning = 1;
phack2.offset = jhack2.offset = firstNode->singleFieldsBefore;
}
else
phack2.offset = jhack2.offset = firstNode->singleFieldsAfter;
}
else
{
phack2.firstSlot = jhack2.firstSlot = (unsigned short) referringNode->slotNumber;
phack2.secondSlot = jhack2.secondSlot = (unsigned short) firstNode->slotNumber;
if (joinTest)
{
if (isNand)
{ jhack2.secondPattern = (unsigned short) firstNode->joinDepth; }
else
{ jhack2.secondPattern = 0; }
jhack2.secondPatternRHS = TRUE;
jhack2.firstPatternLHS = TRUE;
jhack2.firstPattern = (unsigned short) referringNode->joinDepth;
}
if (referringNode->multiFieldsBefore == 0)
{
phack2.fromBeginning = jhack2.fromBeginning = 1;
phack2.offset = jhack2.offset = referringNode->singleFieldsBefore;
}
else
phack2.offset = jhack2.offset = referringNode->singleFieldsAfter;
}
if (joinTest)
theExp = GenConstant(theEnv,OBJ_JN_CMP2,EnvAddBitMap(theEnv,(void *) &jhack2,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars2)));
else
theExp = GenConstant(theEnv,OBJ_PN_CMP2,EnvAddBitMap(theEnv,(void *) &phack2,
(int) sizeof(struct ObjectCmpPNSingleSlotVars2)));
}
/* ===================================
Compare two single-field references
within multifield slots
=================================== */
else
{
ClearBitString((void *) &phack3,(int) sizeof(struct ObjectCmpPNSingleSlotVars3));
ClearBitString((void *) &jhack3,(int) sizeof(struct ObjectCmpJoinSingleSlotVars3));
if (selfNode->negated)
phack3.fail = jhack3.fail = 1;
else
phack3.pass = jhack3.pass = 1;
phack3.firstSlot = jhack3.firstSlot = (unsigned short) firstNode->slotNumber;
phack3.secondSlot = jhack3.secondSlot = (unsigned short) referringNode->slotNumber;
if (firstNode->multiFieldsBefore == 0)
{
phack3.firstFromBeginning = jhack3.firstFromBeginning = 1;
phack3.firstOffset = jhack3.firstOffset = firstNode->singleFieldsBefore;
}
else
phack3.firstOffset = jhack3.firstOffset = firstNode->singleFieldsAfter;
if (referringNode->multiFieldsBefore == 0)
{
phack3.secondFromBeginning = jhack3.secondFromBeginning = 1;
phack3.secondOffset = jhack3.secondOffset = referringNode->singleFieldsBefore;
}
else
phack3.secondOffset = jhack3.secondOffset = referringNode->singleFieldsAfter;
if (joinTest)
{
if (isNand)
{ jhack3.firstPattern = (unsigned short) referringNode->joinDepth; }
else
{ jhack3.firstPattern = 0; }
jhack3.firstPatternRHS = TRUE;
jhack3.secondPatternLHS = TRUE;
jhack3.secondPattern = (unsigned short) referringNode->joinDepth;
theExp = GenConstant(theEnv,OBJ_JN_CMP3,EnvAddBitMap(theEnv,(void *) &jhack3,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars3)));
}
else
theExp = GenConstant(theEnv,OBJ_PN_CMP3,EnvAddBitMap(theEnv,(void *) &phack3,
(int) sizeof(struct ObjectCmpPNSingleSlotVars3)));
}
}
/* ==================================================
General comparison for multifield slot references,
references which require multifield markers, and
object addresses
================================================== */
else
{
theExp = GenConstant(theEnv,FCALL,selfNode->negated ? ExpressionData(theEnv)->PTR_NEQ : ExpressionData(theEnv)->PTR_EQ);
theExp->argList = GenConstant(theEnv,0,NULL);
if (isNand)
{ GenObjectGetVar(theEnv,joinTest,theExp->argList,selfNode,NESTED_RHS); }
else
{ GenObjectGetVar(theEnv,joinTest,theExp->argList,selfNode,RHS); }
theExp->argList->nextArg = GenConstant(theEnv,0,NULL);
GenObjectGetVar(theEnv,joinTest,theExp->argList->nextArg,referringNode,LHS);
}
return(theExp);
}
static void *FactGetVarPN3(
struct lhsParseNode *theNode)
{
struct factGetVarPN3Call hack;
/*===================================================*/
/* Clear the bitmap for storing the argument values. */
/*===================================================*/
ClearBitString(&hack,sizeof(struct factGetVarPN3Call));
/*=======================================*/
/* Store the slot in the fact from which */
/* the value will be retrieved. */
/*=======================================*/
hack.whichSlot = theNode->slotNumber - 1;
/*==============================================================*/
/* If a single field variable value is being retrieved, then... */
/*==============================================================*/
if ((theNode->type == SF_WILDCARD) || (theNode->type == SF_VARIABLE))
{
/*=========================================================*/
/* If no multifield values occur before the variable, then */
/* the variable's value can be retrieved based on its */
/* offset from the beginning of the slot's value */
/* regardless of the number of multifield variables or */
/* wildcards following the variable being retrieved. */
/*=========================================================*/
if (theNode->multiFieldsBefore == 0)
{
hack.fromBeginning = 1;
hack.fromEnd = 0;
hack.beginOffset = theNode->singleFieldsBefore;
hack.endOffset = 0;
}
/*===============================================*/
/* Otherwise the variable is retrieved based its */
/* position relative to the end of the slot. */
/*===============================================*/
else
{
hack.fromBeginning = 0;
hack.fromEnd = 1;
hack.beginOffset = 0;
hack.endOffset = theNode->singleFieldsAfter;
}
return(AddBitMap(&hack,sizeof(struct factGetVarPN3Call)));
}
/*============================================================*/
/* A multifield variable value is being retrieved. This means */
/* that there are no other multifield variables or wildcards */
/* in the slot. The multifield value is retrieved by storing */
/* the number of single field values which come before and */
/* after the multifield value. The multifield value can then */
/* be retrieved based on the length of the value in the slot */
/* and the number of single field values which must occur */
/* before and after the multifield value. */
/*============================================================*/
hack.fromBeginning = 1;
hack.fromEnd = 1;
hack.beginOffset = theNode->singleFieldsBefore;
hack.endOffset = theNode->singleFieldsAfter;
/*=============================*/
/* Return the argument bitmap. */
/*=============================*/
return(AddBitMap(&hack,sizeof(struct factGetVarPN3Call)));
}
/***************************************************************
NAME : GenerateSlotComparisonTest
DESCRIPTION : Generates pattern and join network
expressions for comparing object
pattern variables
INPUTS : 1) A flag indicating if this is a
pattern or join network test
2) The intermediate parse node
for the first variable
3) The intermediate parse node
for the second variable
RETURNS : An expression for comparing the
variables
SIDE EFFECTS : Expression and bitmaps generated
NOTES : The following tests are generated
for the following scenarios:
SF slot w/ SF slot: PN_1 or JN_1
Example: (foo ?x) with (bar ?xy)
SF slot w/ SF reference in MF slot: PN_2 or JN_2
Example: (foo ?x) (bar ? ?x ? ?)
SF reference w/ SF reference: PN_3 or JN_3
Example: (foo ? ?x ?) and (bar ? ? ? ?x)
All other cases: EQ/NEQ general test
Example: (foo $? ?x $?) and (bar ?x)
***************************************************************/
static EXPRESSION *GenerateSlotComparisonTest(
int joinTest,
struct lhsParseNode *selfNode,
struct lhsParseNode *referringNode)
{
EXPRESSION *exp;
struct ObjectCmpPNSingleSlotVars1 phack1;
struct ObjectCmpPNSingleSlotVars2 phack2;
struct ObjectCmpPNSingleSlotVars3 phack3;
struct ObjectCmpJoinSingleSlotVars1 jhack1;
struct ObjectCmpJoinSingleSlotVars2 jhack2;
struct ObjectCmpJoinSingleSlotVars3 jhack3;
/* =========================================================
If we are comparing two single-field slot variables that
don't require multifield markers for lookup, use
a quick comparison. Otherwise, use a general eq/neq with
the pattern variable access routines
========================================================= */
if (IsSimpleSlotVariable(selfNode) && IsSimpleSlotVariable(referringNode))
{
/* ==============================
Compare two single-field slots
============================== */
if ((selfNode->withinMultifieldSlot == FALSE) &&
(referringNode->withinMultifieldSlot == FALSE))
{
ClearBitString((void *) &phack1,(int) sizeof(struct ObjectCmpPNSingleSlotVars1));
ClearBitString((void *) &jhack1,(int) sizeof(struct ObjectCmpJoinSingleSlotVars1));
if (selfNode->negated)
phack1.fail = jhack1.fail = 1;
else
phack1.pass = jhack1.pass = 1;
phack1.firstSlot = jhack1.firstSlot = (unsigned) selfNode->slotNumber;
phack1.secondSlot = jhack1.secondSlot = (unsigned) referringNode->slotNumber;
if (joinTest)
{
jhack1.firstPattern = (unsigned) selfNode->pattern;
jhack1.secondPattern = (unsigned) referringNode->pattern;
exp = GenConstant(OBJ_JN_CMP1,AddBitMap((void *) &jhack1,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars1)));
}
else
exp = GenConstant(OBJ_PN_CMP1,AddBitMap((void *) &phack1,
(int) sizeof(struct ObjectCmpPNSingleSlotVars1)));
}
/* ============================================
Compare a single-field slot with a
single-field in a multifield slot (make sure
the multifield slot reference is first
============================================ */
else if ((selfNode->withinMultifieldSlot == FALSE) ||
(referringNode->withinMultifieldSlot == FALSE))
{
ClearBitString((void *) &phack2,(int) sizeof(struct ObjectCmpPNSingleSlotVars2));
ClearBitString((void *) &jhack2,(int) sizeof(struct ObjectCmpJoinSingleSlotVars2));
if (selfNode->negated)
phack2.fail = jhack2.fail = 1;
else
phack2.pass = jhack2.pass = 1;
if (selfNode->withinMultifieldSlot == TRUE)
{
phack2.firstSlot = jhack2.firstSlot = (unsigned) selfNode->slotNumber;
phack2.secondSlot = jhack2.secondSlot = (unsigned) referringNode->slotNumber;
if (joinTest)
{
jhack2.firstPattern = (unsigned) selfNode->pattern;
jhack2.secondPattern = (unsigned) referringNode->pattern;
}
if (selfNode->multiFieldsBefore == 0)
{
phack2.fromBeginning = jhack2.fromBeginning = 1;
phack2.offset = jhack2.offset = selfNode->singleFieldsBefore;
}
else
phack2.offset = jhack2.offset = selfNode->singleFieldsAfter;
}
else
{
phack2.firstSlot = jhack2.firstSlot = (unsigned) referringNode->slotNumber;
phack2.secondSlot = jhack2.secondSlot = (unsigned) selfNode->slotNumber;
if (joinTest)
{
jhack2.firstPattern = (unsigned) referringNode->pattern;
jhack2.secondPattern = (unsigned) selfNode->pattern;
}
if (referringNode->multiFieldsBefore == 0)
{
phack2.fromBeginning = jhack2.fromBeginning = 1;
phack2.offset = jhack2.offset = referringNode->singleFieldsBefore;
}
else
phack2.offset = jhack2.offset = referringNode->singleFieldsAfter;
}
if (joinTest)
exp = GenConstant(OBJ_JN_CMP2,AddBitMap((void *) &jhack2,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars2)));
else
exp = GenConstant(OBJ_PN_CMP2,AddBitMap((void *) &phack2,
(int) sizeof(struct ObjectCmpPNSingleSlotVars2)));
}
/* ===================================
Compare two single-field references
within multifield slots
=================================== */
else
{
ClearBitString((void *) &phack3,(int) sizeof(struct ObjectCmpPNSingleSlotVars3));
ClearBitString((void *) &jhack3,(int) sizeof(struct ObjectCmpJoinSingleSlotVars3));
if (selfNode->negated)
phack3.fail = jhack3.fail = 1;
else
phack3.pass = jhack3.pass = 1;
phack3.firstSlot = jhack3.firstSlot = (unsigned) selfNode->slotNumber;
phack3.secondSlot = jhack3.secondSlot = (unsigned) referringNode->slotNumber;
if (selfNode->multiFieldsBefore == 0)
{
phack3.firstFromBeginning = jhack3.firstFromBeginning = 1;
phack3.firstOffset = jhack3.firstOffset = selfNode->singleFieldsBefore;
}
else
phack3.firstOffset = jhack3.firstOffset = selfNode->singleFieldsAfter;
if (referringNode->multiFieldsBefore == 0)
{
phack3.secondFromBeginning = jhack3.secondFromBeginning = 1;
phack3.secondOffset = jhack3.secondOffset = referringNode->singleFieldsBefore;
}
else
phack3.secondOffset = jhack3.secondOffset = referringNode->singleFieldsAfter;
if (joinTest)
{
jhack3.firstPattern = (unsigned) selfNode->pattern;
jhack3.secondPattern = (unsigned) referringNode->pattern;
exp = GenConstant(OBJ_JN_CMP3,AddBitMap((void *) &jhack3,
(int) sizeof(struct ObjectCmpJoinSingleSlotVars3)));
}
else
exp = GenConstant(OBJ_PN_CMP3,AddBitMap((void *) &phack3,
(int) sizeof(struct ObjectCmpPNSingleSlotVars3)));
}
}
/* ==================================================
General comparison for multifield slot references,
references which require multifield markers, and
object addresses
================================================== */
else
{
exp = GenConstant(FCALL,selfNode->negated ? PTR_NEQ : PTR_EQ);
exp->argList = GenConstant(0,NULL);
GenObjectGetVar(joinTest,exp->argList,selfNode);
exp->argList->nextArg = GenConstant(0,NULL);
GenObjectGetVar(joinTest,exp->argList->nextArg,referringNode);
}
return(exp);
}
globle struct expr *FactGenPNConstant(
struct lhsParseNode *theField)
{
struct expr *top;
int tempValue;
struct factConstantPN1Call hack1;
struct factConstantPN2Call hack2;
/*=================================================================*/
/* If the value of a single field slot (or relation name) is being */
/* compared against a constant, then use specialized routines for */
/* doing the comparison. */
/*=================================================================*/
if (theField->withinMultifieldSlot == FALSE)
{
ClearBitString(&hack1,sizeof(struct factConstantPN1Call));
if (theField->negated) hack1.testForEquality = FALSE;
else hack1.testForEquality = TRUE;
hack1.whichSlot = theField->slotNumber - 1;
top = GenConstant(FACT_PN_CONSTANT1,AddBitMap(&hack1,sizeof(struct factConstantPN1Call)));
top->argList = GenConstant(theField->type,theField->value);
return(top);
}
/*=================================================================*/
/* If a constant comparison is being done within a multifield slot */
/* and the constant's position has no multifields to the left, */
/* then use the same routine used for the single field slot case, */
/* but include the offset from the beginning of the slot. */
/*=================================================================*/
else if ((theField->multiFieldsBefore == 0) ||
((theField->multiFieldsBefore == 1) && (theField->multiFieldsAfter == 0)))
{
ClearBitString(&hack2,sizeof(struct factConstantPN2Call));
if (theField->negated) hack2.testForEquality = FALSE;
else hack2.testForEquality = TRUE;
hack2.whichSlot = theField->slotNumber - 1;
if (theField->multiFieldsBefore == 0)
{
hack2.fromBeginning = TRUE;
hack2.offset = theField->singleFieldsBefore;
}
else
{
hack2.fromBeginning = FALSE;
hack2.offset = theField->singleFieldsAfter;
}
top = GenConstant(FACT_PN_CONSTANT2,AddBitMap(&hack2,sizeof(struct factConstantPN2Call)));
top->argList = GenConstant(theField->type,theField->value);
return(top);
}
/*===============================================================*/
/* Otherwise, use the equality or inequality function to compare */
/* the constant against the value returned by the appropriate */
/* pattern network variable retrieval function call. */
/*===============================================================*/
else
{
if (theField->negated)
{ top = GenConstant(FCALL,PTR_NEQ); }
else
{ top = GenConstant(FCALL,PTR_EQ); }
tempValue = theField->type;
theField->type = SF_VARIABLE;
top->argList = FactGenGetfield(theField);
theField->type = tempValue;
top->argList->nextArg = GenConstant(theField->type,theField->value);
}
/*===============================================================*/
/* Return the expression for performing the constant comparison. */
/*===============================================================*/
return(top);
}
globle struct expr *FactJNVariableComparison(
struct lhsParseNode *selfNode,
struct lhsParseNode *referringNode)
{
struct expr *top;
struct factCompVarsJN1Call hack1;
struct factCompVarsJN2Call hack2;
/*================================================================*/
/* If two single field slots of a deftemplate are being compared, */
/* then use the following specified variable comparison routine. */
/*================================================================*/
if ((selfNode->withinMultifieldSlot == FALSE) &&
(selfNode->slotNumber > 0) &&
(referringNode->withinMultifieldSlot == FALSE) &&
(referringNode->slotNumber > 0))
{
ClearBitString(&hack1,sizeof(struct factCompVarsJN1Call));
hack1.pass = 0;
hack1.fail = 0;
hack1.slot1 = (unsigned int) selfNode->slotNumber - 1;
hack1.pattern2 = (unsigned int) referringNode->pattern;
if (referringNode->index < 0) hack1.slot2 = 0;
else hack1.slot2 = (unsigned int) referringNode->slotNumber - 1;
if (selfNode->negated) hack1.fail = 1;
else hack1.pass = 1;
top = GenConstant(FACT_JN_CMP1,AddBitMap(&hack1,sizeof(struct factCompVarsJN1Call)));
}
/*===============================================================*/
/* If two single field values are compared and either or both of */
/* them are contained in multifield slots (and the value can be */
/* accessed relative to either the beginning or end of the slot */
/* with no intervening multifield variables), then use the */
/* following specified variable comparison routine. */
/*===============================================================*/
else if ((selfNode->slotNumber > 0) &&
(selfNode->type == SF_VARIABLE) &&
((selfNode->multiFieldsBefore == 0) ||
((selfNode->multiFieldsBefore == 1) &&
(selfNode->multiFieldsAfter == 0))) &&
(referringNode->slotNumber > 0) &&
(referringNode->type == SF_VARIABLE) &&
((referringNode->multiFieldsBefore == 0) ||
(referringNode->multiFieldsAfter == 0)))
{
ClearBitString(&hack2,sizeof(struct factCompVarsJN2Call));
hack2.pass = 0;
hack2.fail = 0;
hack2.slot1 = (unsigned int) selfNode->slotNumber - 1;
hack2.pattern2 = (unsigned int) referringNode->pattern;
hack2.slot2 = (unsigned int) referringNode->slotNumber - 1;
if (selfNode->multiFieldsBefore == 0)
{
hack2.fromBeginning1 = 1;
hack2.offset1 = selfNode->singleFieldsBefore;
}
else
{
hack2.fromBeginning1 = 0;
hack2.offset1 = selfNode->singleFieldsAfter;
}
if (referringNode->multiFieldsBefore == 0)
{
hack2.fromBeginning2 = 1;
hack2.offset2 = referringNode->singleFieldsBefore;
}
else
{
hack2.fromBeginning2 = 0;
hack2.offset2 = referringNode->singleFieldsAfter;
}
if (selfNode->negated) hack2.fail = 1;
else hack2.pass = 1;
top = GenConstant(FACT_JN_CMP2,AddBitMap(&hack2,sizeof(struct factCompVarsJN2Call)));
}
/*===============================================================*/
/* Otherwise, use the equality or inequality function to compare */
/* the values returned by the appropriate join network variable */
/* retrieval function call. */
/*===============================================================*/
else
{
if (selfNode->negated)
{ top = GenConstant(FCALL,PTR_NEQ); }
else
{ top = GenConstant(FCALL,PTR_EQ); }
top->argList = FactGenGetvar(selfNode);
top->argList->nextArg = FactGenGetvar(referringNode);
}
/*======================================*/
/* Return the expression for performing */
/* the variable comparison. */
/*======================================*/
return(top);
}
/***************************************************
NAME : GenObjectGetVar
DESCRIPTION : Generates the expressions necessary
to access object pattern variables
INPUTS : 1) An integer code indicating if
this is a join network reference
or a pattern network reference
2) The expression for which to set
the type and value
3) The lhsParseNode for the
variable reference
4) For a join reference, the side from
which the variable must be retrieved.
RETURNS : Nothing useful
SIDE EFFECTS : The value is a packed long holding
pattern index, slot number,
field index, etc.
NOTES : None
***************************************************/
static void GenObjectGetVar(
void *theEnv,
int joinReference,
EXPRESSION *theItem,
struct lhsParseNode *theNode,
int side)
{
struct ObjectMatchVar1 hack1;
struct ObjectMatchVar2 hack2;
ClearBitString((void *) &hack1,(int) sizeof(struct ObjectMatchVar1));
ClearBitString((void *) &hack2,(int) sizeof(struct ObjectMatchVar2));
if (joinReference)
{
if (side == LHS)
{
hack1.lhs = 1;
hack2.lhs = 1;
hack1.whichPattern = (unsigned short) theNode->joinDepth;
hack2.whichPattern = (unsigned short) theNode->joinDepth;
}
else if (side == RHS)
{
hack1.rhs = 1;
hack2.rhs = 1;
hack1.whichPattern = (unsigned short) 0;
hack2.whichPattern = (unsigned short) 0;
}
else if (side == NESTED_RHS)
{
hack1.rhs = 1;
hack2.rhs = 1;
hack1.whichPattern = (unsigned short) theNode->joinDepth;
hack2.whichPattern = (unsigned short) theNode->joinDepth;
}
else
{
hack1.whichPattern = (unsigned short) theNode->joinDepth;
hack2.whichPattern = (unsigned short) theNode->joinDepth;
}
}
/* ========================
Access an object address
======================== */
if (theNode->slotNumber < 0)
{
hack1.objectAddress = 1;
SetpType(theItem,(joinReference ? OBJ_GET_SLOT_JNVAR1 : OBJ_GET_SLOT_PNVAR1));
theItem->value = EnvAddBitMap(theEnv,(void *) &hack1,(int) sizeof(struct ObjectMatchVar1));
return;
}
/* ======================================
Access the entire contents of the slot
====================================== */
if ((theNode->singleFieldsBefore == 0) &&
(theNode->singleFieldsAfter == 0) &&
(theNode->multiFieldsBefore == 0) &&
(theNode->multiFieldsAfter == 0) &&
((theNode->withinMultifieldSlot == FALSE) ||
(theNode->type == MF_VARIABLE) ||
(theNode->type == MF_WILDCARD)))
{
hack1.allFields = 1;
hack1.whichSlot = (unsigned short) theNode->slotNumber;
theItem->type = (unsigned short) (joinReference ? OBJ_GET_SLOT_JNVAR1 : OBJ_GET_SLOT_PNVAR1);
theItem->value = EnvAddBitMap(theEnv,(void *) &hack1,(int) sizeof(struct ObjectMatchVar1));
return;
}
/* =============================================================
Access a particular field(s) in a multifield slot pattern
containing at most one multifield variable and at least
one (or two if no multifield variables) single-field variable
============================================================= */
if (((theNode->type == SF_WILDCARD) || (theNode->type == SF_VARIABLE) || ConstantType(theNode->type)) &&
((theNode->multiFieldsBefore == 0) || (theNode->multiFieldsAfter == 0)))
{
hack2.whichSlot = (unsigned short) theNode->slotNumber;
if (theNode->multiFieldsBefore == 0)
{
hack2.fromBeginning = 1;
hack2.beginningOffset = theNode->singleFieldsBefore;
}
else
{
hack2.fromEnd = 1;
hack2.endOffset = theNode->singleFieldsAfter;
}
theItem->type = (unsigned short) (joinReference ? OBJ_GET_SLOT_JNVAR2 : OBJ_GET_SLOT_PNVAR2);
theItem->value = EnvAddBitMap(theEnv,(void *) &hack2,sizeof(struct ObjectMatchVar2));
return;
}
if (((theNode->type == MF_WILDCARD) || (theNode->type == MF_VARIABLE) || ConstantType(theNode->type)) &&
(theNode->multiFieldsBefore == 0) &&
(theNode->multiFieldsAfter == 0))
{
hack2.whichSlot = (unsigned short) theNode->slotNumber;
hack2.fromBeginning = 1;
hack2.fromEnd = 1;
hack2.beginningOffset = theNode->singleFieldsBefore;
hack2.endOffset = theNode->singleFieldsAfter;
theItem->type = (unsigned short) (joinReference ? OBJ_GET_SLOT_JNVAR2 : OBJ_GET_SLOT_PNVAR2);
theItem->value = EnvAddBitMap(theEnv,(void *) &hack2,sizeof(struct ObjectMatchVar2));
return;
}
/* ==================================================
General slot field access using multifield markers
================================================== */
hack1.whichSlot = (unsigned short) theNode->slotNumber;
hack1.whichField = (unsigned short) theNode->index;
theItem->type = (unsigned short) (joinReference ? OBJ_GET_SLOT_JNVAR1 : OBJ_GET_SLOT_PNVAR1);
theItem->value = EnvAddBitMap(theEnv,(void *) &hack1,sizeof(struct ObjectMatchVar1));
}
