/************************************************************
NAME : TestEntireChain
DESCRIPTION : Processes all classes in a restriction chain
until done
INPUTS : 1) The current chain
2) The index of the chain restriction
(i.e. the 4th query-variable)
RETURNS : Nothing useful
SIDE EFFECTS : Sets current restriction class
Query instance variables set
Solution sets stored in global list
NOTES : None
************************************************************/
static void TestEntireChain(
QUERY_CLASS *qchain,
int indx)
{
QUERY_CLASS *qptr;
int id;
AbortQuery = TRUE;
for (qptr = qchain ; qptr != NULL ; qptr = qptr->chain)
{
AbortQuery = FALSE;
if ((id = GetTraversalID()) == -1)
return;
TestEntireClass(qptr->theModule,id,qptr->cls,qchain,indx);
ReleaseTraversalID();
if ((HaltExecution == TRUE) || (AbortQuery == TRUE))
return;
}
}
/************************************************************
NAME : TestEntireChain
DESCRIPTION : Processes all classes in a restriction chain
until done
INPUTS : 1) The current chain
2) The index of the chain restriction
(i.e. the 4th query-variable)
RETURNS : Nothing useful
SIDE EFFECTS : Sets current restriction class
Query instance variables set
Solution sets stored in global list
NOTES : None
************************************************************/
static void TestEntireChain(
void *theEnv,
QUERY_CLASS *qchain,
int indx)
{
QUERY_CLASS *qptr;
int id;
InstanceQueryData(theEnv)->AbortQuery = TRUE;
for (qptr = qchain ; qptr != NULL ; qptr = qptr->chain)
{
InstanceQueryData(theEnv)->AbortQuery = FALSE;
if ((id = GetTraversalID(theEnv)) == -1)
return;
TestEntireClass(theEnv,qptr->theModule,id,qptr->cls,qchain,indx);
ReleaseTraversalID(theEnv);
if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (InstanceQueryData(theEnv)->AbortQuery == TRUE))
return;
}
}
/*****************************************************************
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(
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;
SetTraversalID(cls->traversalRecord,id);
if (DefclassInScope(theEnv,execStatus,cls,theModule) == FALSE)
return;
ins = cls->instanceList;
while (ins != NULL)
{
InstanceQueryData(theEnv,execStatus)->QueryCore->solns[indx] = ins;
if (qchain->nxt != NULL)
{
ins->busy++;
TestEntireChain(theEnv,execStatus,qchain->nxt,indx+1);
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)))
{
if (InstanceQueryData(theEnv,execStatus)->QueryCore->action != NULL)
{
ins->busy++;
execStatus->CurrentEvaluationDepth++;
ValueDeinstall(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
EvaluateExpression(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->action,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
ValueInstall(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
execStatus->CurrentEvaluationDepth--;
PeriodicCleanup(theEnv,execStatus,FALSE,TRUE);
ins->busy--;
if (ProcedureFunctionData(theEnv,execStatus)->BreakFlag || ProcedureFunctionData(theEnv,execStatus)->ReturnFlag)
{
InstanceQueryData(theEnv,execStatus)->AbortQuery = TRUE;
break;
}
if (execStatus->HaltExecution == TRUE)
break;
}
else
AddSolution(theEnv,execStatus);
}
}
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(theEnv,execStatus,theModule,id,cls->directSubclasses.classArray[i],qchain,indx);
if ((execStatus->HaltExecution == TRUE) || (InstanceQueryData(theEnv,execStatus)->AbortQuery == TRUE))
return;
}
}
/*****************************************************************
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 : 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(
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;
SetTraversalID(cls->traversalRecord,id);
if (DefclassInScope(theEnv,cls,theModule) == FALSE)
return;
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++;
TestEntireChain(theEnv,qchain->nxt,indx+1);
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)))
{
if (InstanceQueryData(theEnv)->QueryCore->action != NULL)
{
ins->busy++;
ValueDeinstall(theEnv,InstanceQueryData(theEnv)->QueryCore->result);
EvaluateExpression(theEnv,InstanceQueryData(theEnv)->QueryCore->action,InstanceQueryData(theEnv)->QueryCore->result);
ValueInstall(theEnv,InstanceQueryData(theEnv)->QueryCore->result);
ins->busy--;
if (ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
{
InstanceQueryData(theEnv)->AbortQuery = TRUE;
break;
}
if (EvaluationData(theEnv)->HaltExecution == TRUE)
break;
}
else
AddSolution(theEnv);
}
}
ins = ins->nxtClass;
while ((ins != NULL) ? (ins->garbage == 1) : FALSE)
ins = ins->nxtClass;
CleanCurrentGarbageFrame(theEnv,NULL);
CallPeriodicTasks(theEnv);
}
RestorePriorGarbageFrame(theEnv,&newGarbageFrame, oldGarbageFrame,NULL);
CallPeriodicTasks(theEnv);
if (ins != NULL)
return;
for (i = 0 ; i < cls->directSubclasses.classCount ; i++)
{
TestEntireClass(theEnv,theModule,id,cls->directSubclasses.classArray[i],qchain,indx);
if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (InstanceQueryData(theEnv)->AbortQuery == TRUE))
return;
}
}