/******************************************************************************
NAME : QueryDoForAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
executes a user-function for each set as it is found
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set. Also, the action is
executed for every instance set.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
globle void QueryDoForAllInstances(
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
int rcnt;
result->type = SYMBOL;
result->value = FalseSymbol;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg->nextArg,
"do-for-all-instances",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **) gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
QueryCore->action = GetFirstArgument()->nextArg;
QueryCore->result = result;
ValueInstall(QueryCore->result);
TestEntireChain(qclasses,0);
ValueDeinstall(QueryCore->result);
PropagateReturnValue(QueryCore->result);
AbortQuery = FALSE;
BreakFlag = FALSE;
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
}
/******************************************************************************
NAME : QueryDoForInstance
DESCRIPTION : Finds the first set of instances which satisfy the query and
executes a user-action with that set
INPUTS : None
RETURNS : Caller's result buffer
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
Also the action expression is executed zero or once.
Caller's result buffer holds result of user-action
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
globle void QueryDoForInstance(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
qclasses = DetermineQueryClasses(theEnv,GetFirstArgument()->nextArg->nextArg,
"do-for-instance",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore(theEnv);
InstanceQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
InstanceQueryData(theEnv)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv)->QueryCore->query = GetFirstArgument();
InstanceQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
if (TestForFirstInChain(theEnv,qclasses,0) == TRUE)
EvaluateExpression(theEnv,InstanceQueryData(theEnv)->QueryCore->action,result);
InstanceQueryData(theEnv)->AbortQuery = FALSE;
ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
rm(theEnv,(void *) InstanceQueryData(theEnv)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,query_core,InstanceQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryClasses(theEnv,qclasses);
}
/******************************************************************************
NAME : AnyFacts
DESCRIPTION : Determines if there any existing facts which satisfy
the query
INPUTS : None
RETURNS : True if the query is satisfied, false otherwise
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaluates to true - if at all).
NOTES : H/L Syntax : See FactParseQueryNoAction()
******************************************************************************/
void AnyFacts(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
bool testResult;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"any-factp",&rcnt);
if (qtemplates == NULL)
{
returnValue->lexemeValue = FalseSymbol(theEnv);
return;
}
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **) gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
testResult = TestForFirstInChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = false;
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
returnValue->lexemeValue = CreateBoolean(theEnv,testResult);
}
/******************************************************************************
NAME : QueryDoForInstance
DESCRIPTION : Finds the first set of instances which satisfy the query and
executes a user-action with that set
INPUTS : None
RETURNS : Caller's result buffer
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
Also the action expression is executed zero or once.
Caller's result buffer holds result of user-action
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
globle void QueryDoForInstance(
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
int rcnt;
result->type = SYMBOL;
result->value = FalseSymbol;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg->nextArg,
"do-for-instance",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **) gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
QueryCore->action = GetFirstArgument()->nextArg;
if (TestForFirstInChain(qclasses,0) == TRUE)
EvaluateExpression(QueryCore->action,result);
AbortQuery = FALSE;
BreakFlag = FALSE;
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
}
/******************************************************************************
NAME : QueryDoForAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
executes a user-function for each set as it is found
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set. Also, the action is
executed for every fact set.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See FactParseQueryAction()
******************************************************************************/
void QueryDoForAllFacts(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
returnValue->lexemeValue = FalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"do-for-all-facts",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **) gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
FactQueryData(theEnv)->QueryCore->result = returnValue;
RetainUDFV(theEnv,FactQueryData(theEnv)->QueryCore->result);
TestEntireChain(theEnv,qtemplates,0);
ReleaseUDFV(theEnv,FactQueryData(theEnv)->QueryCore->result);
FactQueryData(theEnv)->AbortQuery = false;
ProcedureFunctionData(theEnv)->BreakFlag = false;
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : QueryDoForFact
DESCRIPTION : Finds the first set of facts which satisfy the query and
executes a user-action with that set
INPUTS : None
RETURNS : Caller's result buffer
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaulates to TRUE - if at all).
Also the action expression is executed zero or once.
Caller's result buffer holds result of user-action
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
globle void QueryDoForFact(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"do-for-fact",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
if (TestForFirstInChain(theEnv,qtemplates,0) == TRUE)
EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,result);
FactQueryData(theEnv)->AbortQuery = FALSE;
ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : QueryDoForAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
executes a user-function for each set as it is found
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set. Also, the action is
executed for every fact set.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See FactParseQueryAction()
******************************************************************************/
globle void QueryDoForAllFacts(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"do-for-all-facts",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
FactQueryData(theEnv)->QueryCore->result = result;
ValueInstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
TestEntireChain(theEnv,qtemplates,0);
ValueDeinstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
PropagateReturnValue(theEnv,FactQueryData(theEnv)->QueryCore->result);
FactQueryData(theEnv)->AbortQuery = FALSE;
ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : QueryDoForAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
executes a user-function for each set as it is found
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set. Also, the action is
executed for every instance set.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
globle void QueryDoForAllInstances(
void *theEnv,
EXEC_STATUS,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv,execStatus);
qclasses = DetermineQueryClasses(theEnv,execStatus,GetFirstArgument()->nextArg->nextArg,
"do-for-all-instances",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore(theEnv,execStatus);
InstanceQueryData(theEnv,execStatus)->QueryCore = get_struct(theEnv,execStatus,query_core);
InstanceQueryData(theEnv,execStatus)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,execStatus,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv,execStatus)->QueryCore->query = GetFirstArgument();
InstanceQueryData(theEnv,execStatus)->QueryCore->action = GetFirstArgument()->nextArg;
InstanceQueryData(theEnv,execStatus)->QueryCore->result = result;
ValueInstall(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
TestEntireChain(theEnv,execStatus,qclasses,0);
ValueDeinstall(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
PropagateReturnValue(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->result);
InstanceQueryData(theEnv,execStatus)->AbortQuery = FALSE;
ProcedureFunctionData(theEnv,execStatus)->BreakFlag = FALSE;
rm(theEnv,execStatus,(void *) InstanceQueryData(theEnv,execStatus)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,execStatus,query_core,InstanceQueryData(theEnv,execStatus)->QueryCore);
PopQueryCore(theEnv,execStatus);
DeleteQueryClasses(theEnv,execStatus,qclasses);
}
/******************************************************************************
NAME : DelayedQueryDoForAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
and exceutes a user-action for each set
This function differs from QueryDoForAllInstances() in
that it forms the complete list of query satisfactions
BEFORE executing any actions.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set. The action is executed
for evry query satisfaction.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void DelayedQueryDoForAllInstances(
void *theEnv,
EXEC_STATUS,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
register unsigned i;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv,execStatus);
qclasses = DetermineQueryClasses(theEnv,execStatus,GetFirstArgument()->nextArg->nextArg,
"delayed-do-for-all-instances",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore(theEnv,execStatus);
InstanceQueryData(theEnv,execStatus)->QueryCore = get_struct(theEnv,execStatus,query_core);
InstanceQueryData(theEnv,execStatus)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,execStatus,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv,execStatus)->QueryCore->query = GetFirstArgument();
InstanceQueryData(theEnv,execStatus)->QueryCore->action = NULL;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set = NULL;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_size = rcnt;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,execStatus,qclasses,0);
InstanceQueryData(theEnv,execStatus)->AbortQuery = FALSE;
InstanceQueryData(theEnv,execStatus)->QueryCore->action = GetFirstArgument()->nextArg;
while (InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set != NULL)
{
for (i = 0 ; i < rcnt ; i++)
InstanceQueryData(theEnv,execStatus)->QueryCore->solns[i] = InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set->soln[i];
PopQuerySoln(theEnv,execStatus);
execStatus->CurrentEvaluationDepth++;
EvaluateExpression(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->action,result);
execStatus->CurrentEvaluationDepth--;
if (ProcedureFunctionData(theEnv,execStatus)->ReturnFlag == TRUE)
{ PropagateReturnValue(theEnv,execStatus,result); }
PeriodicCleanup(theEnv,execStatus,FALSE,TRUE);
if (execStatus->HaltExecution || ProcedureFunctionData(theEnv,execStatus)->BreakFlag || ProcedureFunctionData(theEnv,execStatus)->ReturnFlag)
{
while (InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set != NULL)
PopQuerySoln(theEnv,execStatus);
break;
}
}
ProcedureFunctionData(theEnv,execStatus)->BreakFlag = FALSE;
rm(theEnv,execStatus,(void *) InstanceQueryData(theEnv,execStatus)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,execStatus,query_core,InstanceQueryData(theEnv,execStatus)->QueryCore);
PopQueryCore(theEnv,execStatus);
DeleteQueryClasses(theEnv,execStatus,qclasses);
}
/******************************************************************************
NAME : DelayedQueryDoForAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
and exceutes a user-action for each set
This function differs from QueryDoForAllFacts() in
that it forms the complete list of query satisfactions
BEFORE executing any actions.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set. The action is executed
for evry query satisfaction.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See FactParseQueryNoAction()
******************************************************************************/
globle void DelayedQueryDoForAllFacts(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
register unsigned i;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"delayed-do-for-all-facts",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = NULL;
FactQueryData(theEnv)->QueryCore->soln_set = NULL;
FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = FALSE;
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
{
for (i = 0 ; i < rcnt ; i++)
FactQueryData(theEnv)->QueryCore->solns[i] = FactQueryData(theEnv)->QueryCore->soln_set->soln[i];
PopQuerySoln(theEnv);
EvaluationData(theEnv)->CurrentEvaluationDepth++;
EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,result);
EvaluationData(theEnv)->CurrentEvaluationDepth--;
if (ProcedureFunctionData(theEnv)->ReturnFlag == TRUE)
{ PropagateReturnValue(theEnv,result); }
PeriodicCleanup(theEnv,FALSE,TRUE);
if (EvaluationData(theEnv)->HaltExecution || ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
{
while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
PopQuerySoln(theEnv);
break;
}
}
ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : DelayedQueryDoForAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
and exceutes a user-action for each set
This function differs from QueryDoForAllInstances() in
that it forms the complete list of query satisfactions
BEFORE executing any actions.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set. The action is executed
for evry query satisfaction.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void DelayedQueryDoForAllInstances(
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
int rcnt;
register int i;
result->type = SYMBOL;
result->value = FalseSymbol;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg->nextArg,
"delayed-do-for-all-instances",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **) gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
QueryCore->action = NULL;
QueryCore->soln_set = NULL;
QueryCore->soln_size = rcnt;
QueryCore->soln_cnt = 0;
TestEntireChain(qclasses,0);
AbortQuery = FALSE;
QueryCore->action = GetFirstArgument()->nextArg;
while (QueryCore->soln_set != NULL)
{
for (i = 0 ; i < rcnt ; i++)
QueryCore->solns[i] = QueryCore->soln_set->soln[i];
PopQuerySoln();
CurrentEvaluationDepth++;
EvaluateExpression(QueryCore->action,result);
CurrentEvaluationDepth--;
if (ReturnFlag == TRUE)
{ PropagateReturnValue(result); }
PeriodicCleanup(FALSE,TRUE);
if (HaltExecution || BreakFlag || ReturnFlag)
{
while (QueryCore->soln_set != NULL)
PopQuerySoln();
break;
}
}
BreakFlag = FALSE;
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
}
/******************************************************************************
NAME : QueryFindAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
stores their names in the user's multi-field variable
The sets are stored sequentially :
Number of sets = (Multi-field length) / (Set length)
The first set is if the first (set length) atoms of the
multi-field variable, and so on.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindAllInstances(
void *theEnv,
EXEC_STATUS,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
register unsigned i,j;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qclasses = DetermineQueryClasses(theEnv,execStatus,GetFirstArgument()->nextArg,
"find-all-instances",&rcnt);
if (qclasses == NULL)
{
result->value = (void *) EnvCreateMultifield(theEnv,execStatus,0L);
return;
}
PushQueryCore(theEnv,execStatus);
InstanceQueryData(theEnv,execStatus)->QueryCore = get_struct(theEnv,execStatus,query_core);
InstanceQueryData(theEnv,execStatus)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,execStatus,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv,execStatus)->QueryCore->query = GetFirstArgument();
InstanceQueryData(theEnv,execStatus)->QueryCore->action = NULL;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set = NULL;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_size = rcnt;
InstanceQueryData(theEnv,execStatus)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,execStatus,qclasses,0);
InstanceQueryData(theEnv,execStatus)->AbortQuery = FALSE;
result->value = (void *) EnvCreateMultifield(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->soln_cnt * rcnt);
while (InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set != NULL)
{
for (i = 0 , j = (unsigned) (result->end + 2) ; i < rcnt ; i++ , j++)
{
SetMFType(result->value,j,INSTANCE_NAME);
SetMFValue(result->value,j,GetFullInstanceName(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->soln_set->soln[i]));
}
result->end = (long) j-2;
PopQuerySoln(theEnv,execStatus);
}
rm(theEnv,execStatus,(void *) InstanceQueryData(theEnv,execStatus)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,execStatus,query_core,InstanceQueryData(theEnv,execStatus)->QueryCore);
PopQueryCore(theEnv,execStatus);
DeleteQueryClasses(theEnv,execStatus,qclasses);
}
/******************************************************************************
NAME : QueryFindAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
stores their names in the user's multi-field variable
The sets are stored sequentially :
Number of sets = (Multi-field length) / (Set length)
The first set is if the first (set length) atoms of the
multi-field variable, and so on.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindAllFacts(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
register unsigned i,j;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"find-all-facts",&rcnt);
if (qtemplates == NULL)
{
result->value = (void *) EnvCreateMultifield(theEnv,0L);
return;
}
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = NULL;
FactQueryData(theEnv)->QueryCore->soln_set = NULL;
FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = FALSE;
result->value = (void *) EnvCreateMultifield(theEnv,FactQueryData(theEnv)->QueryCore->soln_cnt * rcnt);
while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
{
for (i = 0 , j = (unsigned) (result->end + 2) ; i < rcnt ; i++ , j++)
{
SetMFType(result->value,j,FACT_ADDRESS);
SetMFValue(result->value,j,FactQueryData(theEnv)->QueryCore->soln_set->soln[i]);
}
result->end = (long) j-2;
PopQuerySoln(theEnv);
}
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : QueryFindAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
stores their names in the user's multi-field variable
The sets are stored sequentially :
Number of sets = (Multi-field length) / (Set length)
The first set is if the first (set length) atoms of the
multi-field variable, and so on.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
void QueryFindAllFacts(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
size_t i, j;
returnValue->begin = 0;
returnValue->range = 0;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"find-all-facts",&rcnt);
if (qtemplates == NULL)
{
returnValue->value = CreateMultifield(theEnv,0L);
return;
}
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **) gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = NULL;
FactQueryData(theEnv)->QueryCore->soln_set = NULL;
FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = false;
returnValue->value = CreateMultifield(theEnv,FactQueryData(theEnv)->QueryCore->soln_cnt * rcnt);
while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
{
for (i = 0 , j = returnValue->range ; i < rcnt ; i++ , j++)
{
returnValue->multifieldValue->contents[j].value = FactQueryData(theEnv)->QueryCore->soln_set->soln[i];
}
returnValue->range = j;
PopQuerySoln(theEnv);
}
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : QueryFindAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
stores their names in the user's multi-field variable
The sets are stored sequentially :
Number of sets = (Multi-field length) / (Set length)
The first set is if the first (set length) atoms of the
multi-field variable, and so on.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindAllInstances(
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
int rcnt;
register int i,j;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg,
"find-all-instances",&rcnt);
if (qclasses == NULL)
{
result->value = (void *) CreateMultifield(0L);
return;
}
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **) gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
QueryCore->action = NULL;
QueryCore->soln_set = NULL;
QueryCore->soln_size = rcnt;
QueryCore->soln_cnt = 0;
TestEntireChain(qclasses,0);
AbortQuery = FALSE;
result->value = (void *) CreateMultifield(QueryCore->soln_cnt * rcnt);
while (QueryCore->soln_set != NULL)
{
for (i = 0 , j = result->end + 2 ; i < rcnt ; i++ , j++)
{
SetMFType(result->value,j,INSTANCE_NAME);
SetMFValue(result->value,j,GetFullInstanceName(QueryCore->soln_set->soln[i]));
}
result->end = j-2;
PopQuerySoln();
}
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
}
/******************************************************************************
NAME : QueryFindInstance
DESCRIPTION : Finds the first set of instances which satisfy the query and
stores their names in the user's multi-field variable
INPUTS : Caller's result buffer
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindInstance(
void *theEnv,
EXEC_STATUS,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt,i;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qclasses = DetermineQueryClasses(theEnv,execStatus,GetFirstArgument()->nextArg,
"find-instance",&rcnt);
if (qclasses == NULL)
{
result->value = (void *) EnvCreateMultifield(theEnv,execStatus,0L);
return;
}
PushQueryCore(theEnv,execStatus);
InstanceQueryData(theEnv,execStatus)->QueryCore = get_struct(theEnv,execStatus,query_core);
InstanceQueryData(theEnv,execStatus)->QueryCore->solns = (INSTANCE_TYPE **)
gm2(theEnv,execStatus,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv,execStatus)->QueryCore->query = GetFirstArgument();
if (TestForFirstInChain(theEnv,execStatus,qclasses,0) == TRUE)
{
result->value = (void *) EnvCreateMultifield(theEnv,execStatus,rcnt);
SetpDOEnd(result,rcnt);
for (i = 1 ; i <= rcnt ; i++)
{
SetMFType(result->value,i,INSTANCE_NAME);
SetMFValue(result->value,i,GetFullInstanceName(theEnv,execStatus,InstanceQueryData(theEnv,execStatus)->QueryCore->solns[i - 1]));
}
}
else
result->value = (void *) EnvCreateMultifield(theEnv,execStatus,0L);
InstanceQueryData(theEnv,execStatus)->AbortQuery = FALSE;
rm(theEnv,execStatus,(void *) InstanceQueryData(theEnv,execStatus)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,execStatus,query_core,InstanceQueryData(theEnv,execStatus)->QueryCore);
PopQueryCore(theEnv,execStatus);
DeleteQueryClasses(theEnv,execStatus,qclasses);
}
/******************************************************************************
NAME : QueryFindFact
DESCRIPTION : Finds the first set of facts which satisfy the query and
stores their addresses in the user's multi-field variable
INPUTS : Caller's result buffer
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaulates to TRUE - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindFact(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt,i;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"find-fact",&rcnt);
if (qtemplates == NULL)
{
result->value = (void *) EnvCreateMultifield(theEnv,0L);
return;
}
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **)
gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
if (TestForFirstInChain(theEnv,qtemplates,0) == TRUE)
{
result->value = (void *) EnvCreateMultifield(theEnv,rcnt);
SetpDOEnd(result,rcnt);
for (i = 1 ; i <= rcnt ; i++)
{
SetMFType(result->value,i,FACT_ADDRESS);
SetMFValue(result->value,i,FactQueryData(theEnv)->QueryCore->solns[i - 1]);
}
}
else
result->value = (void *) EnvCreateMultifield(theEnv,0L);
FactQueryData(theEnv)->AbortQuery = FALSE;
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : AnyInstances
DESCRIPTION : Determines if there any existing instances which satisfy
the query
INPUTS : None
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle BOOLEAN AnyInstances()
{
QUERY_CLASS *qclasses;
int rcnt;
int TestResult;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg,
"any-instancep",&rcnt);
if (qclasses == NULL)
return(FALSE);
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **) gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
TestResult = TestForFirstInChain(qclasses,0);
AbortQuery = FALSE;
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
return(TestResult);
}
/******************************************************************************
NAME : QueryFindInstance
DESCRIPTION : Finds the first set of instances which satisfy the query and
stores their names in the user's multi-field variable
INPUTS : Caller's result buffer
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void QueryFindInstance(
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
int rcnt,i;
result->type = MULTIFIELD;
result->begin = 0;
result->end = -1;
qclasses = DetermineQueryClasses(GetFirstArgument()->nextArg,
"find-instance",&rcnt);
if (qclasses == NULL)
{
result->value = (void *) CreateMultifield(0L);
return;
}
PushQueryCore();
QueryCore = get_struct(query_core);
QueryCore->solns = (INSTANCE_TYPE **)
gm2((int) (sizeof(INSTANCE_TYPE *) * rcnt));
QueryCore->query = GetFirstArgument();
if (TestForFirstInChain(qclasses,0) == TRUE)
{
result->value = (void *) CreateMultifield(rcnt);
result->end = rcnt-1;
for (i = 1 ; i <= rcnt ; i++)
{
SetMFType(result->value,i,INSTANCE_NAME);
SetMFValue(result->value,i,GetFullInstanceName(QueryCore->solns[i - 1]));
}
}
else
result->value = (void *) CreateMultifield(0L);
AbortQuery = FALSE;
rm((void *) QueryCore->solns,(int) (sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(query_core,QueryCore);
PopQueryCore();
DeleteQueryClasses(qclasses);
}
/******************************************************************************
NAME : QueryFindFact
DESCRIPTION : Finds the first set of facts which satisfy the query and
stores their addresses in the user's multi-field variable
INPUTS : Caller's result buffer
RETURNS : True if the query is satisfied, false otherwise
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaulates to true - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
void QueryFindFact(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt,i;
returnValue->begin = 0;
returnValue->range = 0;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"find-fact",&rcnt);
if (qtemplates == NULL)
{
returnValue->value = CreateMultifield(theEnv,0L);
return;
}
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **)
gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
if (TestForFirstInChain(theEnv,qtemplates,0) == true)
{
returnValue->value = CreateMultifield(theEnv,rcnt);
returnValue->range = rcnt;
for (i = 0 ; i < rcnt ; i++)
{
returnValue->multifieldValue->contents[i].value = FactQueryData(theEnv)->QueryCore->solns[i];
}
}
else
returnValue->value = CreateMultifield(theEnv,0L);
FactQueryData(theEnv)->AbortQuery = false;
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : AnyInstances
DESCRIPTION : Determines if there any existing instances which satisfy
the query
INPUTS : None
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on instance restrictions
and how early the expression evaulates to TRUE - if at all).
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle intBool AnyInstances(
void *theEnv)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
int TestResult;
qclasses = DetermineQueryClasses(theEnv,GetFirstArgument()->nextArg,
"any-instancep",&rcnt);
if (qclasses == NULL)
return(FALSE);
PushQueryCore(theEnv);
InstanceQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
InstanceQueryData(theEnv)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv)->QueryCore->query = GetFirstArgument();
TestResult = TestForFirstInChain(theEnv,qclasses,0);
InstanceQueryData(theEnv)->AbortQuery = FALSE;
rm(theEnv,(void *) InstanceQueryData(theEnv)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,query_core,InstanceQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryClasses(theEnv,qclasses);
return(TestResult);
}
/******************************************************************************
NAME : AnyFacts
DESCRIPTION : Determines if there any existing facts which satisfy
the query
INPUTS : None
RETURNS : TRUE if the query is satisfied, FALSE otherwise
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaluates to TRUE - if at all).
NOTES : H/L Syntax : See FactParseQueryNoAction()
******************************************************************************/
globle intBool AnyFacts(
void *theEnv)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
int TestResult;
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
"any-factp",&rcnt);
if (qtemplates == NULL)
return(FALSE);
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
TestResult = TestForFirstInChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = FALSE;
rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
return(TestResult);
}
/******************************************************************************
NAME : QueryDoForFact
DESCRIPTION : Finds the first set of facts which satisfy the query and
executes a user-action with that set
INPUTS : None
RETURNS : Caller's result buffer
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
zero or more times (depending on fact restrictions
and how early the expression evaulates to true - if at all).
Also the action expression is executed zero or once.
Caller's result buffer holds result of user-action
NOTES : H/L Syntax : See ParseQueryAction()
******************************************************************************/
void QueryDoForFact(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned i, rcnt;
returnValue->value = FalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"do-for-fact",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **) gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
if (TestForFirstInChain(theEnv,qtemplates,0) == true)
{
for (i = 0; i < rcnt; i++)
{ FactQueryData(theEnv)->QueryCore->solns[i]->patternHeader.busyCount++; }
EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,returnValue);
for (i = 0; i < rcnt; i++)
{ FactQueryData(theEnv)->QueryCore->solns[i]->patternHeader.busyCount--; }
}
FactQueryData(theEnv)->AbortQuery = false;
ProcedureFunctionData(theEnv)->BreakFlag = false;
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
/******************************************************************************
NAME : DelayedQueryDoForAllInstances
DESCRIPTION : Finds all sets of instances which satisfy the query and
and exceutes a user-action for each set
This function differs from QueryDoForAllInstances() in
that it forms the complete list of query satisfactions
BEFORE executing any actions.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query class-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every instance set. The action is executed
for evry query satisfaction.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See ParseQueryNoAction()
******************************************************************************/
globle void DelayedQueryDoForAllInstances(
void *theEnv,
DATA_OBJECT *result)
{
QUERY_CLASS *qclasses;
unsigned rcnt;
register unsigned i;
struct garbageFrame newGarbageFrame;
struct garbageFrame *oldGarbageFrame;
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
qclasses = DetermineQueryClasses(theEnv,GetFirstArgument()->nextArg->nextArg,
"delayed-do-for-all-instances",&rcnt);
if (qclasses == NULL)
return;
PushQueryCore(theEnv);
InstanceQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
InstanceQueryData(theEnv)->QueryCore->solns = (INSTANCE_TYPE **) gm2(theEnv,(sizeof(INSTANCE_TYPE *) * rcnt));
InstanceQueryData(theEnv)->QueryCore->query = GetFirstArgument();
InstanceQueryData(theEnv)->QueryCore->action = NULL;
InstanceQueryData(theEnv)->QueryCore->soln_set = NULL;
InstanceQueryData(theEnv)->QueryCore->soln_size = rcnt;
InstanceQueryData(theEnv)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,qclasses,0);
InstanceQueryData(theEnv)->AbortQuery = FALSE;
InstanceQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
oldGarbageFrame = UtilityData(theEnv)->CurrentGarbageFrame;
memset(&newGarbageFrame,0,sizeof(struct garbageFrame));
newGarbageFrame.priorFrame = oldGarbageFrame;
UtilityData(theEnv)->CurrentGarbageFrame = &newGarbageFrame;
while (InstanceQueryData(theEnv)->QueryCore->soln_set != NULL)
{
for (i = 0 ; i < rcnt ; i++)
InstanceQueryData(theEnv)->QueryCore->solns[i] = InstanceQueryData(theEnv)->QueryCore->soln_set->soln[i];
PopQuerySoln(theEnv);
EvaluateExpression(theEnv,InstanceQueryData(theEnv)->QueryCore->action,result);
if (EvaluationData(theEnv)->HaltExecution || ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
{
while (InstanceQueryData(theEnv)->QueryCore->soln_set != NULL)
PopQuerySoln(theEnv);
break;
}
CleanCurrentGarbageFrame(theEnv,NULL);
CallPeriodicTasks(theEnv);
}
RestorePriorGarbageFrame(theEnv,&newGarbageFrame,oldGarbageFrame,result);
CallPeriodicTasks(theEnv);
ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
rm(theEnv,(void *) InstanceQueryData(theEnv)->QueryCore->solns,(sizeof(INSTANCE_TYPE *) * rcnt));
rtn_struct(theEnv,query_core,InstanceQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryClasses(theEnv,qclasses);
}
/******************************************************************************
NAME : DelayedQueryDoForAllFacts
DESCRIPTION : Finds all sets of facts which satisfy the query and
and exceutes a user-action for each set
This function differs from QueryDoForAllFacts() in
that it forms the complete list of query satisfactions
BEFORE executing any actions.
INPUTS : Caller's result buffer
RETURNS : Nothing useful
SIDE EFFECTS : The query template-expressions are evaluated once,
and the query boolean-expression is evaluated
once for every fact set. The action is executed
for evry query satisfaction.
Caller's result buffer holds result of last action executed.
NOTES : H/L Syntax : See FactParseQueryNoAction()
******************************************************************************/
void DelayedQueryDoForAllFacts(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
QUERY_TEMPLATE *qtemplates;
unsigned rcnt;
unsigned i;
GCBlock gcb;
QUERY_SOLN *theSet;
returnValue->value = FalseSymbol(theEnv);
qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
"delayed-do-for-all-facts",&rcnt);
if (qtemplates == NULL)
return;
PushQueryCore(theEnv);
FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
FactQueryData(theEnv)->QueryCore->solns = (Fact **) gm2(theEnv,(sizeof(Fact *) * rcnt));
FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
FactQueryData(theEnv)->QueryCore->action = NULL;
FactQueryData(theEnv)->QueryCore->soln_set = NULL;
FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
TestEntireChain(theEnv,qtemplates,0);
FactQueryData(theEnv)->AbortQuery = false;
FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
/*==============================================================*/
/* Increment the busy count for all facts in the solution sets. */
/*==============================================================*/
GCBlockStart(theEnv,&gcb);
for (theSet = FactQueryData(theEnv)->QueryCore->soln_set;
theSet != NULL;
theSet = theSet->nxt)
{
for (i = 0; i < rcnt; i++)
{ theSet->soln[i]->patternHeader.busyCount++; }
}
/*=====================*/
/* Perform the action. */
/*=====================*/
for (theSet = FactQueryData(theEnv)->QueryCore->soln_set;
theSet != NULL; )
{
for (i = 0 ; i < rcnt ; i++)
{
if (theSet->soln[i]->garbage)
{ goto nextSet; }
FactQueryData(theEnv)->QueryCore->solns[i] = theSet->soln[i];
}
EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,returnValue);
if (EvaluationData(theEnv)->HaltExecution || ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
{ break; }
CleanCurrentGarbageFrame(theEnv,NULL);
CallPeriodicTasks(theEnv);
nextSet: theSet = theSet->nxt;
}
/*==============================================================*/
/* Decrement the busy count for all facts in the solution sets. */
/*==============================================================*/
for (theSet = FactQueryData(theEnv)->QueryCore->soln_set;
theSet != NULL;
theSet = theSet->nxt)
{
for (i = 0; i < rcnt; i++)
{ theSet->soln[i]->patternHeader.busyCount--; }
}
GCBlockEndUDF(theEnv,&gcb,returnValue);
CallPeriodicTasks(theEnv);
/*==================================*/
/* Deallocate the query structures. */
/*==================================*/
while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
{ PopQuerySoln(theEnv); }
ProcedureFunctionData(theEnv)->BreakFlag = false;
rm(theEnv,FactQueryData(theEnv)->QueryCore->solns,(sizeof(Fact *) * rcnt));
rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
PopQueryCore(theEnv);
DeleteQueryTemplates(theEnv,qtemplates);
}
