/*********************************************************************
NAME : StoreSubclasses
DESCRIPTION : Stores the names of direct or indirect
subclasses for a class in a mutlifield
INPUTS : 1) Caller's multifield buffer
2) Starting index
3) Address of the class
4) Include (1) or exclude (0) indirect subclasses
5) Traversal id
RETURNS : The number of subclass names stored in the multifield
SIDE EFFECTS : Multifield set with subclass names
NOTES : Assumes multifield is big enough to hold subclasses
*********************************************************************/
static unsigned StoreSubclasses(
void *mfval,
unsigned si,
DEFCLASS *cls,
int inhp,
int tvid,
short storeName)
{
long i,classi;
register DEFCLASS *subcls;
for (i = si , classi = 0 ; classi < cls->directSubclasses.classCount ; classi++)
{
subcls = cls->directSubclasses.classArray[classi];
if (TestTraversalID(subcls->traversalRecord,tvid) == 0)
{
SetTraversalID(subcls->traversalRecord,tvid);
if (storeName)
{
SetMFType(mfval,i,SYMBOL);
SetMFValue(mfval,i++,(void *) GetDefclassNamePointer((void *) subcls));
}
else
{
SetMFType(mfval,i,DEFCLASS_PTR);
SetMFValue(mfval,i++,(void *) subcls);
}
if (inhp && (subcls->directSubclasses.classCount != 0))
i += StoreSubclasses(mfval,i,subcls,inhp,tvid,storeName);
}
}
return(i - si);
}
/*****************************************************************
NAME : CountSubclasses
DESCRIPTION : Counts the number of direct or indirect
subclasses for a class
INPUTS : 1) Address of class
2) Include (1) or exclude (0) indirect subclasses
3) Traversal id
RETURNS : The number of subclasses
SIDE EFFECTS : None
NOTES : None
*****************************************************************/
static unsigned CountSubclasses(
DEFCLASS *cls,
int inhp,
int tvid)
{
long i,cnt;
register DEFCLASS *subcls;
for (cnt = 0 , i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
subcls = cls->directSubclasses.classArray[i];
if (TestTraversalID(subcls->traversalRecord,tvid) == 0)
{
cnt++;
SetTraversalID(subcls->traversalRecord,tvid);
if (inhp && (subcls->directSubclasses.classCount != 0))
cnt += CountSubclasses(subcls,inhp,tvid);
}
}
return(cnt);
}
/*****************************************************************
NAME : TestEntireClass
DESCRIPTION : Processes all instances in a class and then
all subclasses of a class until done
INPUTS : 1) The module for which classes tested must be
in scope
2) Visitation traversal id
3) The class
4) The current class restriction chain
5) The index of the current restriction
RETURNS : Nothing useful
SIDE EFFECTS : Instance variable values set
Solution sets stored in global list
NOTES : None
*****************************************************************/
static void TestEntireClass(
struct defmodule *theModule,
int id,
DEFCLASS *cls,
QUERY_CLASS *qchain,
int indx)
{
register unsigned i;
INSTANCE_TYPE *ins;
DATA_OBJECT temp;
if (TestTraversalID(cls->traversalRecord,id))
return;
SetTraversalID(cls->traversalRecord,id);
if (DefclassInScope(cls,theModule) == FALSE)
return;
ins = cls->instanceList;
while (ins != NULL)
{
QueryCore->solns[indx] = ins;
if (qchain->nxt != NULL)
{
ins->busy++;
TestEntireChain(qchain->nxt,indx+1);
ins->busy--;
if ((HaltExecution == TRUE) || (AbortQuery == TRUE))
break;
}
else
{
ins->busy++;
CurrentEvaluationDepth++;
EvaluateExpression(QueryCore->query,&temp);
CurrentEvaluationDepth--;
PeriodicCleanup(FALSE,TRUE);
ins->busy--;
if (HaltExecution == TRUE)
break;
if ((temp.type != SYMBOL) ? TRUE :
(temp.value != FalseSymbol))
{
if (QueryCore->action != NULL)
{
ins->busy++;
CurrentEvaluationDepth++;
ValueDeinstall(QueryCore->result);
EvaluateExpression(QueryCore->action,QueryCore->result);
ValueInstall(QueryCore->result);
CurrentEvaluationDepth--;
PeriodicCleanup(FALSE,TRUE);
ins->busy--;
if (BreakFlag || ReturnFlag)
{
AbortQuery = TRUE;
break;
}
if (HaltExecution == TRUE)
break;
}
else
AddSolution();
}
}
ins = ins->nxtClass;
while ((ins != NULL) ? (ins->garbage == 1) : FALSE)
ins = ins->nxtClass;
}
if (ins != NULL)
return;
for (i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
TestEntireClass(theModule,id,cls->directSubclasses.classArray[i],qchain,indx);
if ((HaltExecution == TRUE) || (AbortQuery == TRUE))
return;
}
}
/*****************************************************************
NAME : TestForFirstInstanceInClass
DESCRIPTION : Processes all instances in a class and then
all subclasses of a class until success or done
INPUTS : 1) The module for which classes tested must be
in scope
2) Visitation traversal id
3) The class
4) The current class restriction chain
5) The index of the current restriction
RETURNS : TRUE if query succeeds, FALSE otherwise
SIDE EFFECTS : Instance variable values set
NOTES : None
*****************************************************************/
static int TestForFirstInstanceInClass(
void *theEnv,
EXEC_STATUS,
struct defmodule *theModule,
int id,
DEFCLASS *cls,
QUERY_CLASS *qchain,
int indx)
{
long i;
INSTANCE_TYPE *ins;
DATA_OBJECT temp;
if (TestTraversalID(cls->traversalRecord,id))
return(FALSE);
SetTraversalID(cls->traversalRecord,id);
if (DefclassInScope(theEnv,execStatus,cls,theModule) == FALSE)
return(FALSE);
ins = cls->instanceList;
while (ins != NULL)
{
InstanceQueryData(theEnv,execStatus)->QueryCore->solns[indx] = ins;
if (qchain->nxt != NULL)
{
ins->busy++;
if (TestForFirstInChain(theEnv,execStatus,qchain->nxt,indx+1) == TRUE)
{
ins->busy--;
break;
}
ins->busy--;
if ((execStatus->HaltExecution == TRUE) || (InstanceQueryData(theEnv,execStatus)->AbortQuery == TRUE))
break;
}
else
{
ins->busy++;
execStatus->CurrentEvaluationDepth++;
EvaluateExpression(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->query,&temp);
execStatus->CurrentEvaluationDepth--;
PeriodicCleanup(theEnv,execStatus,FALSE,TRUE);
ins->busy--;
if (execStatus->HaltExecution == TRUE)
break;
if ((temp.type != SYMBOL) ? TRUE :
(temp.value != EnvFalseSymbol(theEnv,execStatus)))
break;
}
ins = ins->nxtClass;
while ((ins != NULL) ? (ins->garbage == 1) : FALSE)
ins = ins->nxtClass;
}
if (ins != NULL)
return(((execStatus->HaltExecution == TRUE) || (InstanceQueryData(theEnv,execStatus)->AbortQuery == TRUE))
? FALSE : TRUE);
for (i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
if (TestForFirstInstanceInClass(theEnv,execStatus,theModule,id,cls->directSubclasses.classArray[i],
qchain,indx))
return(TRUE);
if ((execStatus->HaltExecution == TRUE) || (InstanceQueryData(theEnv,execStatus)->AbortQuery == TRUE))
return(FALSE);
}
return(FALSE);
}
/*****************************************************************
NAME : TestForFirstInstanceInClass
DESCRIPTION : Processes all instances in a class and then
all subclasses of a class until success or done
INPUTS : 1) The module for which classes tested must be
in scope
2) Visitation traversal id
3) The class
4) The current class restriction chain
5) The index of the current restriction
RETURNS : TRUE if query succeeds, FALSE otherwise
SIDE EFFECTS : Instance variable values set
NOTES : None
*****************************************************************/
static int TestForFirstInstanceInClass(
void *theEnv,
struct defmodule *theModule,
int id,
DEFCLASS *cls,
QUERY_CLASS *qchain,
int indx)
{
long i;
INSTANCE_TYPE *ins;
DATA_OBJECT temp;
struct garbageFrame newGarbageFrame;
struct garbageFrame *oldGarbageFrame;
if (TestTraversalID(cls->traversalRecord,id))
return(FALSE);
SetTraversalID(cls->traversalRecord,id);
if (DefclassInScope(theEnv,cls,theModule) == FALSE)
return(FALSE);
oldGarbageFrame = UtilityData(theEnv)->CurrentGarbageFrame;
memset(&newGarbageFrame,0,sizeof(struct garbageFrame));
newGarbageFrame.priorFrame = oldGarbageFrame;
UtilityData(theEnv)->CurrentGarbageFrame = &newGarbageFrame;
ins = cls->instanceList;
while (ins != NULL)
{
InstanceQueryData(theEnv)->QueryCore->solns[indx] = ins;
if (qchain->nxt != NULL)
{
ins->busy++;
if (TestForFirstInChain(theEnv,qchain->nxt,indx+1) == TRUE)
{
ins->busy--;
break;
}
ins->busy--;
if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (InstanceQueryData(theEnv)->AbortQuery == TRUE))
break;
}
else
{
ins->busy++;
EvaluateExpression(theEnv,InstanceQueryData(theEnv)->QueryCore->query,&temp);
ins->busy--;
if (EvaluationData(theEnv)->HaltExecution == TRUE)
break;
if ((temp.type != SYMBOL) ? TRUE :
(temp.value != EnvFalseSymbol(theEnv)))
break;
}
CleanCurrentGarbageFrame(theEnv,NULL);
CallPeriodicTasks(theEnv);
ins = ins->nxtClass;
while ((ins != NULL) ? (ins->garbage == 1) : FALSE)
ins = ins->nxtClass;
}
RestorePriorGarbageFrame(theEnv,&newGarbageFrame, oldGarbageFrame,NULL);
CallPeriodicTasks(theEnv);
if (ins != NULL)
return(((EvaluationData(theEnv)->HaltExecution == TRUE) || (InstanceQueryData(theEnv)->AbortQuery == TRUE))
? FALSE : TRUE);
for (i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
if (TestForFirstInstanceInClass(theEnv,theModule,id,cls->directSubclasses.classArray[i],
qchain,indx))
return(TRUE);
if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (InstanceQueryData(theEnv)->AbortQuery == TRUE))
return(FALSE);
}
return(FALSE);
}