src/clipsrules/core/insquery.c Source File

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