src/clipsrules/core/factqury.c Source File

00001    /*******************************************************/
00002    /*      "C" Language Integrated Production System      */
00003    /*                                                     */
00004    /*               CLIPS Version 6.24  07/01/05          */
00005    /*                                                     */
00006    /*                                                     */
00007    /*******************************************************/
00008 
00009 /*************************************************************/
00010 /* Purpose: Query Functions for Objects                      */
00011 /*                                                           */
00012 /* Principal Programmer(s):                                  */
00013 /*      Brian L. Dantes                                      */
00014 /*                                                           */
00015 /* Contributing Programmer(s):                               */
00016 /*      Gary D. Riley                                        */
00017 /*                                                           */
00018 /* Revision History:                                         */
00019 /*                                                           */
00020 /*      6.23: Added fact-set queries.                        */
00021 /*                                                           */
00022 /*      6.24: Corrected errors when compiling as a C++ file. */
00023 /*            DR0868                                         */
00024 /*                                                           */
00025 /*            Renamed BOOLEAN macro type to intBool.         */
00026 /*                                                           */
00027 /*************************************************************/
00028 
00029 /* =========================================
00030    *****************************************
00031                EXTERNAL DEFINITIONS
00032    =========================================
00033    ***************************************** */
00034 #include "setup.h"
00035 
00036 #if FACT_SET_QUERIES
00037 
00038 #include "argacces.h"
00039 #include "envrnmnt.h"
00040 #include "memalloc.h"
00041 #include "exprnpsr.h"
00042 #include "modulutl.h"
00043 #include "tmpltutl.h"
00044 #include "insfun.h"
00045 #include "factqpsr.h"
00046 #include "prcdrfun.h"
00047 #include "router.h"
00048 #include "utility.h"
00049 
00050 #define _FACTQURY_SOURCE_
00051 #include "factqury.h"
00052 
00053 /* =========================================
00054    *****************************************
00055       INTERNALLY VISIBLE FUNCTION HEADERS
00056    =========================================
00057    ***************************************** */
00058 
00059 static void PushQueryCore(void *);
00060 static void PopQueryCore(void *);
00061 static QUERY_CORE *FindQueryCore(void *,int);
00062 static QUERY_TEMPLATE *DetermineQueryTemplates(void *,EXPRESSION *,char *,unsigned *);
00063 static QUERY_TEMPLATE *FormChain(void *,char *,DATA_OBJECT *);
00064 static void DeleteQueryTemplates(void *,QUERY_TEMPLATE *);
00065 static int TestForFirstInChain(void *,QUERY_TEMPLATE *,int);
00066 static int TestForFirstFactInTemplate(void *,struct deftemplate *,QUERY_TEMPLATE *,int);
00067 static void TestEntireChain(void *,QUERY_TEMPLATE *,int);
00068 static void TestEntireTemplate(void *,struct deftemplate *,QUERY_TEMPLATE *,int);
00069 static void AddSolution(void *);
00070 static void PopQuerySoln(void *);
00071 
00072 /****************************************************
00073   NAME         : SetupFactQuery
00074   DESCRIPTION  : Initializes fact query H/L
00075                    functions and parsers
00076   INPUTS       : None
00077   RETURNS      : Nothing useful
00078   SIDE EFFECTS : Sets up kernel functions and parsers
00079   NOTES        : None
00080  ****************************************************/
00081 globle void SetupFactQuery(
00082   void *theEnv)
00083   {
00084    AllocateEnvironmentData(theEnv,FACT_QUERY_DATA,sizeof(struct factQueryData),NULL);
00085 
00086 #if RUN_TIME                                                 
00087    FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMETER_STRING);
00088 #endif  
00089 
00090 #if ! RUN_TIME
00091    FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,QUERY_DELIMETER_STRING);
00092    IncrementSymbolCount(FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL);
00093 
00094    EnvDefineFunction2(theEnv,"(query-fact)",'u',
00095                   PTIEF GetQueryFact,"GetQueryFact",NULL);
00096 
00097    EnvDefineFunction2(theEnv,"(query-fact-slot)",'u',
00098                   PTIEF GetQueryFactSlot,"GetQueryFactSlot",NULL);
00099 
00100    EnvDefineFunction2(theEnv,"any-factp",'b',PTIEF AnyFacts,"AnyFacts",NULL);
00101    AddFunctionParser(theEnv,"any-factp",FactParseQueryNoAction);
00102 
00103    EnvDefineFunction2(theEnv,"find-fact",'m',
00104                   PTIEF QueryFindFact,"QueryFindFact",NULL);
00105    AddFunctionParser(theEnv,"find-fact",FactParseQueryNoAction);
00106 
00107    EnvDefineFunction2(theEnv,"find-all-facts",'m',
00108                   PTIEF QueryFindAllFacts,"QueryFindAllFacts",NULL);
00109    AddFunctionParser(theEnv,"find-all-facts",FactParseQueryNoAction);
00110 
00111    EnvDefineFunction2(theEnv,"do-for-fact",'u',
00112                   PTIEF QueryDoForFact,"QueryDoForFact",NULL);
00113    AddFunctionParser(theEnv,"do-for-fact",FactParseQueryAction);
00114 
00115    EnvDefineFunction2(theEnv,"do-for-all-facts",'u',
00116                   PTIEF QueryDoForAllFacts,"QueryDoForAllFacts",NULL);
00117    AddFunctionParser(theEnv,"do-for-all-facts",FactParseQueryAction);
00118 
00119    EnvDefineFunction2(theEnv,"delayed-do-for-all-facts",'u',
00120                   PTIEF DelayedQueryDoForAllFacts,
00121                   "DelayedQueryDoForAllFacts",NULL);
00122    AddFunctionParser(theEnv,"delayed-do-for-all-facts",FactParseQueryAction);
00123 #endif
00124   }
00125 
00126 /*************************************************************
00127   NAME         : GetQueryFact
00128   DESCRIPTION  : Internal function for referring to fact
00129                     array on fact-queries
00130   INPUTS       : None
00131   RETURNS      : The name of the specified fact-set member
00132   SIDE EFFECTS : None
00133   NOTES        : H/L Syntax : ((query-fact) <index>)
00134  *************************************************************/
00135 globle void GetQueryFact(
00136   void *theEnv,
00137   DATA_OBJECT *result)
00138   {
00139    register QUERY_CORE *core;
00140 
00141    core = FindQueryCore(theEnv,ValueToInteger(GetpValue(GetFirstArgument())));
00142    
00143    result->type = FACT_ADDRESS;
00144    result->value = core->solns[ValueToInteger(GetpValue(GetFirstArgument()->nextArg))];
00145   }
00146 
00147 /***************************************************************************
00148   NAME         : GetQueryFactSlot
00149   DESCRIPTION  : Internal function for referring to slots of fact in
00150                     fact array on fact-queries
00151   INPUTS       : The caller's result buffer
00152   RETURNS      : Nothing useful
00153   SIDE EFFECTS : Caller's result buffer set appropriately
00154   NOTES        : H/L Syntax : ((query-fact-slot) <index> <slot-name>)
00155  **************************************************************************/
00156 globle void GetQueryFactSlot(
00157   void *theEnv,
00158   DATA_OBJECT *result)
00159   {
00160    struct fact *theFact;
00161    DATA_OBJECT temp;
00162    QUERY_CORE *core;
00163    short position;
00164 
00165    result->type = SYMBOL;
00166    result->value = EnvFalseSymbol(theEnv);
00167 
00168    core = FindQueryCore(theEnv,ValueToInteger(GetpValue(GetFirstArgument())));
00169    theFact = core->solns[ValueToInteger(GetpValue(GetFirstArgument()->nextArg))];
00170    EvaluateExpression(theEnv,GetFirstArgument()->nextArg->nextArg,&temp);
00171    if (temp.type != SYMBOL)
00172      {
00173       ExpectedTypeError1(theEnv,"get",1,"symbol");
00174       SetEvaluationError(theEnv,TRUE);
00175       return;
00176      }
00177      
00178    /*==================================================*/
00179    /* Make sure the slot exists (the symbol implied is */
00180    /* used for the implied slot of an ordered fact).   */
00181    /*==================================================*/
00182 
00183    if (theFact->whichDeftemplate->implied)
00184      {
00185       if (strcmp(ValueToString(temp.value),"implied") != 0)
00186         {
00187          SlotExistError(theEnv,ValueToString(temp.value),"fact-set query");
00188          return;
00189         }
00190       position = 1;
00191      }
00192 
00193    else if (FindSlot((struct deftemplate *) theFact->whichDeftemplate,
00194                      (struct symbolHashNode *) temp.value,&position) == NULL)
00195      {
00196       SlotExistError(theEnv,ValueToString(temp.value),"fact-set query");
00197       return;
00198      }
00199      
00200    result->type = theFact->theProposition.theFields[position-1].type;
00201    result->value = theFact->theProposition.theFields[position-1].value;
00202    if (result->type == MULTIFIELD)
00203      {
00204       SetpDOBegin(result,1);
00205       SetpDOEnd(result,((struct multifield *) result->value)->multifieldLength);
00206      }
00207   }
00208 
00209 /* =============================================================================
00210    =============================================================================
00211    Following are the instance query functions :
00212 
00213      any-factp         : Determines if any facts satisfy the query
00214      find-fact         : Finds first (set of) fact(s) which satisfies
00215                                the query and stores it in a multi-field
00216      find-all-facts    : Finds all (sets of) facts which satisfy the
00217                                the query and stores them in a multi-field
00218      do-for-fact       : Executes a given action for the first (set of)
00219                                fact(s) which satisfy the query
00220      do-for-all-facts  : Executes an action for all facts which satisfy
00221                                the query as they are found
00222      delayed-do-for-all-facts : Same as above - except that the list of facts
00223                                which satisfy the query is formed before any
00224                                actions are executed
00225 
00226      Fact candidate search algorithm :
00227 
00228      All permutations of first restriction template facts with other
00229        restriction template facts (Rightmost are varied first)
00230 
00231      For any one template, fact are examined in the order they were defined
00232 
00233      Example :
00234      (deftemplate a (slot v))
00235      (deftemplate b (slot v))
00236      (deftemplate c (slot v))
00237      (assert (a (v a1)))
00238      (assert (a (v a2)))
00239      (assert (b (v b1)))
00240      (assert (b (v b2)))
00241      (assert (c (v c1)))
00242      (assert (c (v c2)))
00243      (assert (d (v d1)))
00244      (assert (d (v d2)))
00245 
00246      (any-factp ((?a a b) (?b c)) <query>)
00247 
00248      The permutations (?a ?b) would be examined in the following order :
00249 
00250      (a1 c1),(a1 c2),(a2 c1),(a2 c2),
00251      (b1 c1),(b1 c2),(b2 c1),(b2 c2)
00252 
00253    =============================================================================
00254    ============================================================================= */
00255 
00256 /******************************************************************************
00257   NAME         : AnyFacts
00258   DESCRIPTION  : Determines if there any existing facts which satisfy
00259                    the query
00260   INPUTS       : None
00261   RETURNS      : TRUE if the query is satisfied, FALSE otherwise
00262   SIDE EFFECTS : The query template-expressions are evaluated once,
00263                    and the query boolean-expression is evaluated
00264                    zero or more times (depending on fact restrictions
00265                    and how early the expression evaluates to TRUE - if at all).
00266   NOTES        : H/L Syntax : See FactParseQueryNoAction()
00267  ******************************************************************************/
00268 globle intBool AnyFacts(
00269   void *theEnv)
00270   {
00271    QUERY_TEMPLATE *qtemplates;
00272    unsigned rcnt;
00273    int TestResult;
00274 
00275    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
00276                                       "any-factp",&rcnt);
00277    if (qtemplates == NULL)
00278      return(FALSE);
00279    PushQueryCore(theEnv);
00280    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00281    FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
00282    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00283    TestResult = TestForFirstInChain(theEnv,qtemplates,0);
00284    FactQueryData(theEnv)->AbortQuery = FALSE;
00285    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00286    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00287    PopQueryCore(theEnv);
00288    DeleteQueryTemplates(theEnv,qtemplates);
00289    return(TestResult);
00290   }
00291 
00292 /******************************************************************************
00293   NAME         : QueryFindFact
00294   DESCRIPTION  : Finds the first set of facts which satisfy the query and
00295                    stores their addresses in the user's multi-field variable
00296   INPUTS       : Caller's result buffer
00297   RETURNS      : TRUE if the query is satisfied, FALSE otherwise
00298   SIDE EFFECTS : The query template-expressions are evaluated once,
00299                    and the query boolean-expression is evaluated
00300                    zero or more times (depending on fact restrictions
00301                    and how early the expression evaulates to TRUE - if at all).
00302   NOTES        : H/L Syntax : See ParseQueryNoAction()
00303  ******************************************************************************/
00304 globle void QueryFindFact(
00305   void *theEnv,
00306   DATA_OBJECT *result)
00307   {
00308    QUERY_TEMPLATE *qtemplates;
00309    unsigned rcnt,i;
00310 
00311    result->type = MULTIFIELD;
00312    result->begin = 0;
00313    result->end = -1;
00314    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
00315                                       "find-fact",&rcnt);
00316    if (qtemplates == NULL)
00317      {
00318       result->value = (void *) EnvCreateMultifield(theEnv,0L);
00319       return;
00320      }
00321    PushQueryCore(theEnv);
00322    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00323    FactQueryData(theEnv)->QueryCore->solns = (struct fact **)
00324                       gm2(theEnv,(sizeof(struct fact *) * rcnt));
00325    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00326    if (TestForFirstInChain(theEnv,qtemplates,0) == TRUE)
00327      {
00328       result->value = (void *) EnvCreateMultifield(theEnv,rcnt);
00329       SetpDOEnd(result,rcnt);
00330       for (i = 1 ; i <= rcnt ; i++)
00331         {
00332          SetMFType(result->value,i,FACT_ADDRESS);
00333          SetMFValue(result->value,i,FactQueryData(theEnv)->QueryCore->solns[i - 1]);
00334         }
00335      }
00336    else
00337       result->value = (void *) EnvCreateMultifield(theEnv,0L);
00338    FactQueryData(theEnv)->AbortQuery = FALSE;
00339    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00340    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00341    PopQueryCore(theEnv);
00342    DeleteQueryTemplates(theEnv,qtemplates);
00343   }
00344 
00345 /******************************************************************************
00346   NAME         : QueryFindAllFacts
00347   DESCRIPTION  : Finds all sets of facts which satisfy the query and
00348                    stores their names in the user's multi-field variable
00349 
00350                  The sets are stored sequentially :
00351 
00352                    Number of sets = (Multi-field length) / (Set length)
00353 
00354                  The first set is if the first (set length) atoms of the
00355                    multi-field variable, and so on.
00356   INPUTS       : Caller's result buffer
00357   RETURNS      : Nothing useful
00358   SIDE EFFECTS : The query template-expressions are evaluated once,
00359                    and the query boolean-expression is evaluated
00360                    once for every fact set.
00361   NOTES        : H/L Syntax : See ParseQueryNoAction()
00362  ******************************************************************************/
00363 globle void QueryFindAllFacts(
00364   void *theEnv,
00365   DATA_OBJECT *result)
00366   {
00367    QUERY_TEMPLATE *qtemplates;
00368    unsigned rcnt;
00369    register unsigned i,j;
00370 
00371    result->type = MULTIFIELD;
00372    result->begin = 0;
00373    result->end = -1;
00374    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg,
00375                                       "find-all-facts",&rcnt);
00376    if (qtemplates == NULL)
00377      {
00378       result->value = (void *) EnvCreateMultifield(theEnv,0L);
00379       return;
00380      }
00381    PushQueryCore(theEnv);
00382    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00383    FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
00384    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00385    FactQueryData(theEnv)->QueryCore->action = NULL;
00386    FactQueryData(theEnv)->QueryCore->soln_set = NULL;
00387    FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
00388    FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
00389    TestEntireChain(theEnv,qtemplates,0);
00390    FactQueryData(theEnv)->AbortQuery = FALSE;
00391    result->value = (void *) EnvCreateMultifield(theEnv,FactQueryData(theEnv)->QueryCore->soln_cnt * rcnt);
00392    while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
00393      {
00394       for (i = 0 , j = (unsigned) (result->end + 2) ; i < rcnt ; i++ , j++)
00395         {
00396          SetMFType(result->value,j,FACT_ADDRESS);
00397          SetMFValue(result->value,j,FactQueryData(theEnv)->QueryCore->soln_set->soln[i]);
00398         }
00399       result->end = (long) j-2;
00400       PopQuerySoln(theEnv);
00401      }
00402    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00403    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00404    PopQueryCore(theEnv);
00405    DeleteQueryTemplates(theEnv,qtemplates);
00406   }
00407 
00408 /******************************************************************************
00409   NAME         : QueryDoForFact
00410   DESCRIPTION  : Finds the first set of facts which satisfy the query and
00411                    executes a user-action with that set
00412   INPUTS       : None
00413   RETURNS      : Caller's result buffer
00414   SIDE EFFECTS : The query template-expressions are evaluated once,
00415                    and the query boolean-expression is evaluated
00416                    zero or more times (depending on fact restrictions
00417                    and how early the expression evaulates to TRUE - if at all).
00418                    Also the action expression is executed zero or once.
00419                  Caller's result buffer holds result of user-action
00420   NOTES        : H/L Syntax : See ParseQueryAction()
00421  ******************************************************************************/
00422 globle void QueryDoForFact(
00423   void *theEnv,
00424   DATA_OBJECT *result)
00425   {
00426    QUERY_TEMPLATE *qtemplates;
00427    unsigned rcnt;
00428 
00429    result->type = SYMBOL;
00430    result->value = EnvFalseSymbol(theEnv);
00431    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
00432                                       "do-for-fact",&rcnt);
00433    if (qtemplates == NULL)
00434      return;
00435    PushQueryCore(theEnv);
00436    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00437    FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
00438    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00439    FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
00440    if (TestForFirstInChain(theEnv,qtemplates,0) == TRUE)
00441      EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,result);
00442    FactQueryData(theEnv)->AbortQuery = FALSE;
00443    ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
00444    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00445    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00446    PopQueryCore(theEnv);
00447    DeleteQueryTemplates(theEnv,qtemplates);
00448   }
00449 
00450 /******************************************************************************
00451   NAME         : QueryDoForAllFacts
00452   DESCRIPTION  : Finds all sets of facts which satisfy the query and
00453                    executes a user-function for each set as it is found
00454   INPUTS       : Caller's result buffer
00455   RETURNS      : Nothing useful
00456   SIDE EFFECTS : The query template-expressions are evaluated once,
00457                    and the query boolean-expression is evaluated
00458                    once for every fact set.  Also, the action is
00459                    executed for every fact set.
00460                  Caller's result buffer holds result of last action executed.
00461   NOTES        : H/L Syntax : See FactParseQueryAction()
00462  ******************************************************************************/
00463 globle void QueryDoForAllFacts(
00464   void *theEnv,
00465   DATA_OBJECT *result)
00466   {
00467    QUERY_TEMPLATE *qtemplates;
00468    unsigned rcnt;
00469 
00470    result->type = SYMBOL;
00471    result->value = EnvFalseSymbol(theEnv);
00472    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
00473                                       "do-for-all-facts",&rcnt);
00474    if (qtemplates == NULL)
00475      return;
00476    PushQueryCore(theEnv);
00477    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00478    FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
00479    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00480    FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
00481    FactQueryData(theEnv)->QueryCore->result = result;
00482    ValueInstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
00483    TestEntireChain(theEnv,qtemplates,0);
00484    ValueDeinstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
00485    PropagateReturnValue(theEnv,FactQueryData(theEnv)->QueryCore->result);
00486    FactQueryData(theEnv)->AbortQuery = FALSE;
00487    ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
00488    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00489    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00490    PopQueryCore(theEnv);
00491    DeleteQueryTemplates(theEnv,qtemplates);
00492   }
00493 
00494 /******************************************************************************
00495   NAME         : DelayedQueryDoForAllFacts
00496   DESCRIPTION  : Finds all sets of facts which satisfy the query and
00497                    and exceutes a user-action for each set
00498 
00499                  This function differs from QueryDoForAllFacts() in
00500                    that it forms the complete list of query satisfactions
00501                    BEFORE executing any actions.
00502   INPUTS       : Caller's result buffer
00503   RETURNS      : Nothing useful
00504   SIDE EFFECTS : The query template-expressions are evaluated once,
00505                    and the query boolean-expression is evaluated
00506                    once for every fact set.  The action is executed
00507                    for evry query satisfaction.
00508                  Caller's result buffer holds result of last action executed.
00509   NOTES        : H/L Syntax : See FactParseQueryNoAction()
00510  ******************************************************************************/
00511 globle void DelayedQueryDoForAllFacts(
00512   void *theEnv,
00513   DATA_OBJECT *result)
00514   {
00515    QUERY_TEMPLATE *qtemplates;
00516    unsigned rcnt;
00517    register unsigned i;
00518 
00519    result->type = SYMBOL;
00520    result->value = EnvFalseSymbol(theEnv);
00521    qtemplates = DetermineQueryTemplates(theEnv,GetFirstArgument()->nextArg->nextArg,
00522                                       "delayed-do-for-all-facts",&rcnt);
00523    if (qtemplates == NULL)
00524      return;
00525    PushQueryCore(theEnv);
00526    FactQueryData(theEnv)->QueryCore = get_struct(theEnv,query_core);
00527    FactQueryData(theEnv)->QueryCore->solns = (struct fact **) gm2(theEnv,(sizeof(struct fact *) * rcnt));
00528    FactQueryData(theEnv)->QueryCore->query = GetFirstArgument();
00529    FactQueryData(theEnv)->QueryCore->action = NULL;
00530    FactQueryData(theEnv)->QueryCore->soln_set = NULL;
00531    FactQueryData(theEnv)->QueryCore->soln_size = rcnt;
00532    FactQueryData(theEnv)->QueryCore->soln_cnt = 0;
00533    TestEntireChain(theEnv,qtemplates,0);
00534    FactQueryData(theEnv)->AbortQuery = FALSE;
00535    FactQueryData(theEnv)->QueryCore->action = GetFirstArgument()->nextArg;
00536    while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
00537      {
00538       for (i = 0 ; i < rcnt ; i++)
00539         FactQueryData(theEnv)->QueryCore->solns[i] = FactQueryData(theEnv)->QueryCore->soln_set->soln[i];
00540       PopQuerySoln(theEnv);
00541       EvaluationData(theEnv)->CurrentEvaluationDepth++;
00542       EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,result);
00543       EvaluationData(theEnv)->CurrentEvaluationDepth--;
00544       if (ProcedureFunctionData(theEnv)->ReturnFlag == TRUE)
00545         { PropagateReturnValue(theEnv,result); }
00546       PeriodicCleanup(theEnv,FALSE,TRUE);
00547       if (EvaluationData(theEnv)->HaltExecution || ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
00548         {
00549          while (FactQueryData(theEnv)->QueryCore->soln_set != NULL)
00550            PopQuerySoln(theEnv);
00551          break;
00552         }
00553      }
00554    ProcedureFunctionData(theEnv)->BreakFlag = FALSE;
00555    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->solns,(sizeof(struct fact *) * rcnt));
00556    rtn_struct(theEnv,query_core,FactQueryData(theEnv)->QueryCore);
00557    PopQueryCore(theEnv);
00558    DeleteQueryTemplates(theEnv,qtemplates);
00559   }
00560 
00561 /* =========================================
00562    *****************************************
00563           INTERNALLY VISIBLE FUNCTIONS
00564    =========================================
00565    ***************************************** */
00566 
00567 /*******************************************************
00568   NAME         : PushQueryCore
00569   DESCRIPTION  : Pushes the current QueryCore onto stack
00570   INPUTS       : None
00571   RETURNS      : Nothing useful
00572   SIDE EFFECTS : Allocates new stack node and changes
00573                    QueryCoreStack
00574   NOTES        : None
00575  *******************************************************/
00576 static void PushQueryCore(
00577   void *theEnv)
00578   {
00579    QUERY_STACK *qptr;
00580 
00581    qptr = get_struct(theEnv,query_stack);
00582    qptr->core = FactQueryData(theEnv)->QueryCore;
00583    qptr->nxt = FactQueryData(theEnv)->QueryCoreStack;
00584    FactQueryData(theEnv)->QueryCoreStack = qptr;
00585   }
00586 
00587 /******************************************************
00588   NAME         : PopQueryCore
00589   DESCRIPTION  : Pops top of QueryCore stack and
00590                    restores QueryCore to this core
00591   INPUTS       : None
00592   RETURNS      : Nothing useful
00593   SIDE EFFECTS : Stack node deallocated, QueryCoreStack
00594                    changed and QueryCore reset
00595   NOTES        : Assumes stack is not empty
00596  ******************************************************/
00597 static void PopQueryCore(
00598   void *theEnv)
00599   {
00600    QUERY_STACK *qptr;
00601 
00602    FactQueryData(theEnv)->QueryCore = FactQueryData(theEnv)->QueryCoreStack->core;
00603    qptr = FactQueryData(theEnv)->QueryCoreStack;
00604    FactQueryData(theEnv)->QueryCoreStack = FactQueryData(theEnv)->QueryCoreStack->nxt;
00605    rtn_struct(theEnv,query_stack,qptr);
00606   }
00607 
00608 /***************************************************
00609   NAME         : FindQueryCore
00610   DESCRIPTION  : Looks up a QueryCore Stack Frame
00611                     Depth 0 is current frame
00612                     1 is next deepest, etc.
00613   INPUTS       : Depth
00614   RETURNS      : Address of query core stack frame
00615   SIDE EFFECTS : None
00616   NOTES        : None
00617  ***************************************************/
00618 static QUERY_CORE *FindQueryCore(
00619   void *theEnv,
00620   int depth)
00621   {
00622    QUERY_STACK *qptr;
00623 
00624    if (depth == 0)
00625      return(FactQueryData(theEnv)->QueryCore);
00626    qptr = FactQueryData(theEnv)->QueryCoreStack;
00627    while (depth > 1)
00628      {
00629       qptr = qptr->nxt;
00630       depth--;
00631      }
00632    return(qptr->core);
00633   }
00634 
00635 /**********************************************************
00636   NAME         : DetermineQueryTemplates
00637   DESCRIPTION  : Builds a list of templates to be used in
00638                    fact queries - uses parse form.
00639   INPUTS       : 1) The parse template expression chain
00640                  2) The name of the function being executed
00641                  3) Caller's buffer for restriction count
00642                     (# of separate lists)
00643   RETURNS      : The query list, or NULL on errors
00644   SIDE EFFECTS : Memory allocated for list
00645                  Busy count incremented for all templates
00646   NOTES        : Each restriction is linked by nxt pointer,
00647                    multiple templates in a restriction are
00648                    linked by the chain pointer.
00649                  Rcnt caller's buffer is set to reflect the
00650                    total number of chains
00651                  Assumes classExp is not NULL and that each
00652                    restriction chain is terminated with
00653                    the QUERY_DELIMITER_SYMBOL "(QDS)"
00654  **********************************************************/
00655 static QUERY_TEMPLATE *DetermineQueryTemplates(
00656   void *theEnv,
00657   EXPRESSION *templateExp,
00658   char *func,
00659   unsigned *rcnt)
00660   {
00661    QUERY_TEMPLATE *clist = NULL,*cnxt = NULL,*cchain = NULL,*tmp;
00662    int new_list = FALSE;
00663    DATA_OBJECT temp;
00664 
00665    *rcnt = 0;
00666    while (templateExp != NULL)
00667      {
00668       if (EvaluateExpression(theEnv,templateExp,&temp))
00669         {
00670          DeleteQueryTemplates(theEnv,clist);
00671          return(NULL);
00672         }
00673       if ((temp.type == SYMBOL) && (temp.value == (void *) FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL))
00674         {
00675          new_list = TRUE;
00676          (*rcnt)++;
00677         }
00678       else if ((tmp = FormChain(theEnv,func,&temp)) != NULL)
00679         {
00680          if (clist == NULL)
00681            clist = cnxt = cchain = tmp;
00682          else if (new_list == TRUE)
00683            {
00684             new_list = FALSE;
00685             cnxt->nxt = tmp;
00686             cnxt = cchain = tmp;
00687            }
00688          else
00689            cchain->chain = tmp;
00690          while (cchain->chain != NULL)
00691            cchain = cchain->chain;
00692         }
00693       else
00694         {
00695          SyntaxErrorMessage(theEnv,"fact-set query class restrictions");
00696          DeleteQueryTemplates(theEnv,clist);
00697          SetEvaluationError(theEnv,TRUE);
00698          return(NULL);
00699         }
00700       templateExp = templateExp->nextArg;
00701      }
00702    return(clist);
00703   }
00704 
00705 /*************************************************************
00706   NAME         : FormChain
00707   DESCRIPTION  : Builds a list of classes to be used in
00708                    fact queries - uses parse form.
00709   INPUTS       : 1) Name of calling function for error msgs
00710                  2) Data object - must be a symbol or a
00711                       multifield value containing all symbols
00712                  The symbols must be names of existing templates
00713   RETURNS      : The query chain, or NULL on errors
00714   SIDE EFFECTS : Memory allocated for chain
00715                  Busy count incremented for all templates
00716   NOTES        : None
00717  *************************************************************/
00718 static QUERY_TEMPLATE *FormChain(
00719   void *theEnv,
00720   char *func,
00721   DATA_OBJECT *val)
00722   {
00723    struct deftemplate *templatePtr;
00724    QUERY_TEMPLATE *head,*bot,*tmp;
00725    register long i,end; /* 6.04 Bug Fix */
00726    char *templateName;
00727    int count;
00728 
00729    if (val->type == DEFTEMPLATE_PTR)
00730      {
00731       IncrementDeftemplateBusyCount(theEnv,(void *) val->value);
00732       head = get_struct(theEnv,query_template);
00733       head->templatePtr = (struct deftemplate *) val->value;
00734 
00735       head->chain = NULL;
00736       head->nxt = NULL;
00737       return(head);
00738      }
00739    if (val->type == SYMBOL)
00740      {
00741       /* ===============================================
00742          Allow instance-set query restrictions to have a
00743          module specifier as part of the class name,
00744          but search imported defclasses too if a
00745          module specifier is not given
00746          =============================================== */
00747          
00748       templatePtr = (struct deftemplate *)
00749                        FindImportedConstruct(theEnv,"deftemplate",NULL,DOPToString(val),
00750                                              &count,TRUE,NULL);
00751       if (templatePtr == NULL)
00752         {
00753          CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",DOPToString(val),func);
00754          return(NULL);
00755         }
00756       IncrementDeftemplateBusyCount(theEnv,(void *) templatePtr);
00757       head = get_struct(theEnv,query_template);
00758       head->templatePtr = templatePtr;
00759 
00760       head->chain = NULL;
00761       head->nxt = NULL;
00762       return(head);
00763      }
00764    if (val->type == MULTIFIELD)
00765      {
00766       head = bot = NULL;
00767       end = GetpDOEnd(val);
00768       for (i = GetpDOBegin(val) ; i <= end ; i++)
00769         {
00770          if (GetMFType(val->value,i) == SYMBOL)
00771            {
00772             templateName = ValueToString(GetMFValue(val->value,i));
00773             
00774             templatePtr = (struct deftemplate *)
00775                        FindImportedConstruct(theEnv,"deftemplate",NULL,templateName,
00776                                              &count,TRUE,NULL);
00777 
00778             if (templatePtr == NULL)
00779               {
00780                CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",templateName,func);
00781                DeleteQueryTemplates(theEnv,head);
00782                return(NULL);
00783               }
00784            }
00785          else
00786            {
00787             DeleteQueryTemplates(theEnv,head);
00788             return(NULL);
00789            }
00790          IncrementDeftemplateBusyCount(theEnv,(void *) templatePtr);
00791          tmp = get_struct(theEnv,query_template);
00792          tmp->templatePtr = templatePtr;
00793 
00794          tmp->chain = NULL;
00795          tmp->nxt = NULL;
00796          if (head == NULL)
00797            head = tmp;
00798          else
00799            bot->chain = tmp;
00800          bot = tmp;
00801         }
00802       return(head);
00803      }
00804    return(NULL);
00805   }
00806 
00807 /******************************************************
00808   NAME         : DeleteQueryTemplates
00809   DESCRIPTION  : Deletes a query class-list
00810   INPUTS       : The query list address
00811   RETURNS      : Nothing useful
00812   SIDE EFFECTS : Nodes deallocated
00813                  Busy count decremented for all templates
00814   NOTES        : None
00815  ******************************************************/
00816 static void DeleteQueryTemplates(
00817   void *theEnv,
00818   QUERY_TEMPLATE *qlist)
00819   {
00820    QUERY_TEMPLATE *tmp;
00821 
00822    while (qlist != NULL)
00823      {
00824       while (qlist->chain != NULL)
00825         {
00826          tmp = qlist->chain;
00827          qlist->chain = qlist->chain->chain;
00828          DecrementDeftemplateBusyCount(theEnv,(void *) tmp->templatePtr);
00829          rtn_struct(theEnv,query_template,tmp);
00830         }
00831       tmp = qlist;
00832       qlist = qlist->nxt;
00833       DecrementDeftemplateBusyCount(theEnv,(void *) tmp->templatePtr);
00834       rtn_struct(theEnv,query_template,tmp);
00835      }
00836   }
00837 
00838 /************************************************************
00839   NAME         : TestForFirstInChain
00840   DESCRIPTION  : Processes all templates in a restriction chain
00841                    until success or done
00842   INPUTS       : 1) The current chain
00843                  2) The index of the chain restriction
00844                      (e.g. the 4th query-variable)
00845   RETURNS      : TRUE if query succeeds, FALSE otherwise
00846   SIDE EFFECTS : Sets current restriction class
00847                  Fact variable values set
00848   NOTES        : None
00849  ************************************************************/
00850 static int TestForFirstInChain(
00851   void *theEnv,
00852   QUERY_TEMPLATE *qchain,
00853   int indx)
00854   {
00855    QUERY_TEMPLATE *qptr;
00856 
00857    FactQueryData(theEnv)->AbortQuery = TRUE;
00858    for (qptr = qchain ; qptr != NULL ; qptr = qptr->chain)
00859      {
00860       FactQueryData(theEnv)->AbortQuery = FALSE;
00861 
00862       if (TestForFirstFactInTemplate(theEnv,qptr->templatePtr,qchain,indx))
00863         { return(TRUE); }
00864         
00865       if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (FactQueryData(theEnv)->AbortQuery == TRUE))
00866         return(FALSE);
00867      }
00868    return(FALSE);
00869   }
00870 
00871 /*****************************************************************
00872   NAME         : TestForFirstFactInTemplate
00873   DESCRIPTION  : Processes all facts in a template
00874   INPUTS       : 1) Visitation traversal id
00875                  2) The template
00876                  3) The current template restriction chain
00877                  4) The index of the current restriction
00878   RETURNS      : TRUE if query succeeds, FALSE otherwise
00879   SIDE EFFECTS : Fact variable values set
00880   NOTES        : None
00881  *****************************************************************/
00882 static int TestForFirstFactInTemplate(
00883   void *theEnv,
00884   struct deftemplate *templatePtr,
00885   QUERY_TEMPLATE *qchain,
00886   int indx)
00887   {
00888    struct fact *theFact;
00889    DATA_OBJECT temp;
00890 
00891    theFact = templatePtr->factList;
00892    while (theFact != NULL)
00893      {
00894       FactQueryData(theEnv)->QueryCore->solns[indx] = theFact;
00895       if (qchain->nxt != NULL)
00896         {
00897          theFact->factHeader.busyCount++;
00898          if (TestForFirstInChain(theEnv,qchain->nxt,indx+1) == TRUE)
00899            {
00900             theFact->factHeader.busyCount--;
00901             break;
00902            }
00903          theFact->factHeader.busyCount--;
00904          if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (FactQueryData(theEnv)->AbortQuery == TRUE))
00905            break;
00906         }
00907       else
00908         {
00909          theFact->factHeader.busyCount++;
00910          EvaluationData(theEnv)->CurrentEvaluationDepth++;
00911          EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->query,&temp);
00912          EvaluationData(theEnv)->CurrentEvaluationDepth--;
00913          PeriodicCleanup(theEnv,FALSE,TRUE);
00914          theFact->factHeader.busyCount--;
00915          if (EvaluationData(theEnv)->HaltExecution == TRUE)
00916            break;
00917          if ((temp.type != SYMBOL) ? TRUE :
00918              (temp.value != EnvFalseSymbol(theEnv)))
00919            break;
00920         }
00921       theFact = theFact->nextTemplateFact;
00922       while ((theFact != NULL) ? (theFact->garbage == 1) : FALSE)
00923         theFact = theFact->nextTemplateFact;
00924      }
00925 
00926    if (theFact != NULL)
00927      return(((EvaluationData(theEnv)->HaltExecution == TRUE) || (FactQueryData(theEnv)->AbortQuery == TRUE))
00928              ? FALSE : TRUE);
00929 
00930    return(FALSE);
00931   }
00932 
00933 /************************************************************
00934   NAME         : TestEntireChain
00935   DESCRIPTION  : Processes all templates in a restriction chain
00936                    until done
00937   INPUTS       : 1) The current chain
00938                  2) The index of the chain restriction
00939                      (i.e. the 4th query-variable)
00940   RETURNS      : Nothing useful
00941   SIDE EFFECTS : Sets current restriction template
00942                  Query fact variables set
00943                  Solution sets stored in global list
00944   NOTES        : None
00945  ************************************************************/
00946 static void TestEntireChain(
00947   void *theEnv,
00948   QUERY_TEMPLATE *qchain,
00949   int indx)
00950   {
00951    QUERY_TEMPLATE *qptr;
00952 
00953    FactQueryData(theEnv)->AbortQuery = TRUE;
00954    for (qptr = qchain ; qptr != NULL ; qptr = qptr->chain)
00955      {
00956       FactQueryData(theEnv)->AbortQuery = FALSE;
00957 
00958       TestEntireTemplate(theEnv,qptr->templatePtr,qchain,indx);
00959 
00960       if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (FactQueryData(theEnv)->AbortQuery == TRUE))
00961         return;
00962      }
00963   }
00964 
00965 /*****************************************************************
00966   NAME         : TestEntireTemplate
00967   DESCRIPTION  : Processes all facts in a template
00968   INPUTS       : 1) The module for which templates tested must be
00969                     in scope
00970                  3) The template
00971                  4) The current template restriction chain
00972                  5) The index of the current restriction
00973   RETURNS      : Nothing useful
00974   SIDE EFFECTS : Instance variable values set
00975                  Solution sets stored in global list
00976   NOTES        : None
00977  *****************************************************************/
00978 static void TestEntireTemplate(
00979   void *theEnv,
00980   struct deftemplate *templatePtr,
00981   QUERY_TEMPLATE *qchain,
00982   int indx)
00983   {
00984    struct fact *theFact;
00985    DATA_OBJECT temp;
00986 
00987    theFact = templatePtr->factList;
00988    while (theFact != NULL)
00989      {
00990       FactQueryData(theEnv)->QueryCore->solns[indx] = theFact;
00991       if (qchain->nxt != NULL)
00992         {
00993          theFact->factHeader.busyCount++;
00994          TestEntireChain(theEnv,qchain->nxt,indx+1);
00995          theFact->factHeader.busyCount--;
00996          if ((EvaluationData(theEnv)->HaltExecution == TRUE) || (FactQueryData(theEnv)->AbortQuery == TRUE))
00997            break;
00998         }
00999       else
01000         { 
01001          theFact->factHeader.busyCount++;
01002          EvaluationData(theEnv)->CurrentEvaluationDepth++;
01003          EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->query,&temp);
01004          EvaluationData(theEnv)->CurrentEvaluationDepth--;
01005          PeriodicCleanup(theEnv,FALSE,TRUE);
01006          theFact->factHeader.busyCount--;
01007          if (EvaluationData(theEnv)->HaltExecution == TRUE)
01008            break;
01009          if ((temp.type != SYMBOL) ? TRUE :
01010              (temp.value != EnvFalseSymbol(theEnv)))
01011            {
01012             if (FactQueryData(theEnv)->QueryCore->action != NULL)
01013               {
01014                theFact->factHeader.busyCount++;
01015                EvaluationData(theEnv)->CurrentEvaluationDepth++;
01016                ValueDeinstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
01017                EvaluateExpression(theEnv,FactQueryData(theEnv)->QueryCore->action,FactQueryData(theEnv)->QueryCore->result);
01018                ValueInstall(theEnv,FactQueryData(theEnv)->QueryCore->result);
01019                EvaluationData(theEnv)->CurrentEvaluationDepth--;
01020                PeriodicCleanup(theEnv,FALSE,TRUE);
01021                theFact->factHeader.busyCount--;
01022                if (ProcedureFunctionData(theEnv)->BreakFlag || ProcedureFunctionData(theEnv)->ReturnFlag)
01023                  {
01024                   FactQueryData(theEnv)->AbortQuery = TRUE;
01025                   break;
01026                  }
01027                if (EvaluationData(theEnv)->HaltExecution == TRUE)
01028                  break;
01029               }
01030             else
01031               AddSolution(theEnv);
01032            }
01033         }
01034         
01035       theFact = theFact->nextTemplateFact;
01036       while ((theFact != NULL) ? (theFact->garbage == 1) : FALSE)
01037         theFact = theFact->nextTemplateFact;
01038      }
01039   }
01040 
01041 /***************************************************************************
01042   NAME         : AddSolution
01043   DESCRIPTION  : Adds the current fact set to a global list of
01044                    solutions
01045   INPUTS       : None
01046   RETURNS      : Nothing useful
01047   SIDE EFFECTS : Global list and count updated
01048   NOTES        : Solutions are stored as sequential arrays of struct fact *
01049  ***************************************************************************/
01050 static void AddSolution(
01051   void *theEnv)
01052   {
01053    QUERY_SOLN *new_soln;
01054    register unsigned i;
01055 
01056    new_soln = (QUERY_SOLN *) gm2(theEnv,(int) sizeof(QUERY_SOLN));
01057    new_soln->soln = (struct fact **)
01058                     gm2(theEnv,(sizeof(struct fact *) * (FactQueryData(theEnv)->QueryCore->soln_size)));
01059    for (i = 0 ; i < FactQueryData(theEnv)->QueryCore->soln_size ; i++)
01060      new_soln->soln[i] = FactQueryData(theEnv)->QueryCore->solns[i];
01061    new_soln->nxt = NULL;
01062    if (FactQueryData(theEnv)->QueryCore->soln_set == NULL)
01063      FactQueryData(theEnv)->QueryCore->soln_set = new_soln;
01064    else
01065      FactQueryData(theEnv)->QueryCore->soln_bottom->nxt = new_soln;
01066    FactQueryData(theEnv)->QueryCore->soln_bottom = new_soln;
01067    FactQueryData(theEnv)->QueryCore->soln_cnt++;
01068   }
01069 
01070 /***************************************************
01071   NAME         : PopQuerySoln
01072   DESCRIPTION  : Deallocates the topmost solution
01073                    set for an fact-set query
01074   INPUTS       : None
01075   RETURNS      : Nothing useful
01076   SIDE EFFECTS : Solution set deallocated
01077   NOTES        : Assumes QueryCore->soln_set != 0
01078  ***************************************************/
01079 static void PopQuerySoln(
01080   void *theEnv)
01081   {
01082    FactQueryData(theEnv)->QueryCore->soln_bottom = FactQueryData(theEnv)->QueryCore->soln_set;
01083    FactQueryData(theEnv)->QueryCore->soln_set = FactQueryData(theEnv)->QueryCore->soln_set->nxt;
01084    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->soln_bottom->soln,
01085       (sizeof(struct fact *) * FactQueryData(theEnv)->QueryCore->soln_size));
01086    rm(theEnv,(void *) FactQueryData(theEnv)->QueryCore->soln_bottom,sizeof(QUERY_SOLN));
01087   }
01088   
01089 #endif
01090 
01091