clipsruby 0.0.2

data/ext/clipsruby/crstrtgy.c

@@ -0,0 +1,1088 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*            CLIPS Version 6.40  08/25/16             */
+   /*                                                     */
+   /*         CONFLICT RESOLUTION STRATEGY MODULE         */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Used to determine where a new activation is      */
+/*   placed on the agenda based on the current conflict      */
+/*   resolution strategy (depth, breadth, mea, lex,          */
+/*   simplicity, or complexity). Also provides the           */
+/*   set-strategy and get-strategy commands.                 */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.23: Corrected compilation errors for files         */
+/*            generated by constructs-to-c. DR0861           */
+/*                                                           */
+/*      6.24: Removed CONFLICT_RESOLUTION_STRATEGIES         */
+/*            compilation flag.                              */
+/*                                                           */
+/*      6.30: Added salience groups to improve performance   */
+/*            with large numbers of activations of different */
+/*            saliences.                                     */
+/*                                                           */
+/*            Removed pseudo-facts used for not CEs.         */
+/*                                                           */
+/*            Changed integer type/precision.                */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*      6.40: Pragma once and other inclusion changes.       */
+/*                                                           */
+/*            Added support for booleans with <stdbool.h>.   */
+/*                                                           */
+/*            Removed use of void pointers for specific      */
+/*            data structures.                               */
+/*                                                           */
+/*            ALLOW_ENVIRONMENT_GLOBALS no longer supported. */
+/*                                                           */
+/*            UDF redesign.                                  */
+/*                                                           */
+/*************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+#include "setup.h"
+
+#if DEFRULE_CONSTRUCT
+
+#include "agenda.h"
+#include "argacces.h"
+#include "constant.h"
+#include "envrnmnt.h"
+#include "memalloc.h"
+#include "pattern.h"
+#include "reteutil.h"
+
+#include "crstrtgy.h"
+
+#define GetMatchingItem(x,i) ((x->basis->binds[i].gm.theMatch != NULL) ? \
+                              (x->basis->binds[i].gm.theMatch->matchingItem) : NULL)
+
+/***************************************/
+/* LOCAL INTERNAL FUNCTION DEFINITIONS */
+/***************************************/
+
+   static Activation             *PlaceDepthActivation(Activation *,struct salienceGroup *);
+   static Activation             *PlaceBreadthActivation(Activation *,struct salienceGroup *);
+   static Activation             *PlaceLEXActivation(Environment *,Activation *,struct salienceGroup *);
+   static Activation             *PlaceMEAActivation(Environment *,Activation *,struct salienceGroup *);
+   static Activation             *PlaceComplexityActivation(Activation *,struct salienceGroup *);
+   static Activation             *PlaceSimplicityActivation(Activation *,struct salienceGroup *);
+   static Activation             *PlaceRandomActivation(Activation *,struct salienceGroup *);
+   static int                     ComparePartialMatches(Environment *,Activation *,Activation *);
+   static const char             *GetStrategyName(StrategyType);
+   static unsigned long long     *SortPartialMatch(Environment *,struct partialMatch *);
+
+/******************************************************************/
+/* PlaceActivation: Coordinates placement of an activation on the */
+/*   Agenda based on the current conflict resolution strategy.    */
+/******************************************************************/
+void PlaceActivation(
+  Environment *theEnv,
+  Activation **whichAgenda,
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   Activation *placeAfter = NULL;
+
+   /*================================================*/
+   /* Set the flag which indicates that a change has */
+   /* been made to the agenda.                       */
+   /*================================================*/
+
+   SetAgendaChanged(theEnv,true);
+
+   /*=============================================*/
+   /* Determine the location where the activation */
+   /* should be placed in the agenda based on the */
+   /* current conflict resolution strategy.       */
+   /*==============================================*/
+
+   if (*whichAgenda != NULL)
+     {
+      switch (AgendaData(theEnv)->Strategy)
+        {
+         case DEPTH_STRATEGY:
+           placeAfter = PlaceDepthActivation(newActivation,theGroup);
+           break;
+
+         case BREADTH_STRATEGY:
+           placeAfter = PlaceBreadthActivation(newActivation,theGroup);
+           break;
+
+         case LEX_STRATEGY:
+           placeAfter = PlaceLEXActivation(theEnv,newActivation,theGroup);
+           break;
+
+         case MEA_STRATEGY:
+           placeAfter = PlaceMEAActivation(theEnv,newActivation,theGroup);
+           break;
+
+         case COMPLEXITY_STRATEGY:
+           placeAfter = PlaceComplexityActivation(newActivation,theGroup);
+           break;
+
+         case SIMPLICITY_STRATEGY:
+           placeAfter = PlaceSimplicityActivation(newActivation,theGroup);
+           break;
+
+         case RANDOM_STRATEGY:
+           placeAfter = PlaceRandomActivation(newActivation,theGroup);
+           break;
+        }
+     }
+   else
+     {
+      theGroup->first = newActivation;
+      theGroup->last = newActivation;
+     }
+
+   /*==============================================================*/
+   /* Place the activation at the appropriate place in the agenda. */
+   /*==============================================================*/
+
+   if (placeAfter == NULL) /* then place it at the beginning of then agenda. */
+     {
+      newActivation->next = *whichAgenda;
+      *whichAgenda = newActivation;
+      if (newActivation->next != NULL) newActivation->next->prev = newActivation;
+     }
+   else /* insert it in the agenda. */
+     {
+      newActivation->next = placeAfter->next;
+      newActivation->prev = placeAfter;
+      placeAfter->next = newActivation;
+      if (newActivation->next != NULL)
+        { newActivation->next->prev = newActivation; }
+     }
+  }
+
+/*******************************************************************/
+/* PlaceDepthActivation: Determines the location in the agenda     */
+/*    where a new activation should be placed for the depth        */
+/*    strategy. Returns a pointer to the activation after which    */
+/*    the new activation should be placed (or NULL if the          */
+/*    activation should be placed at the beginning of the agenda). */
+/*******************************************************************/
+static Activation *PlaceDepthActivation(
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   Activation *lastAct, *actPtr;
+   unsigned long long timetag;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the activation is placed before      */
+   /* activations with an equal or lower timetag (yielding    */
+   /* depth first traversal).                                 */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      if (timetag < actPtr->timetag)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else
+        { break; }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return(lastAct);
+  }
+
+/*******************************************************************/
+/* PlaceBreadthActivation: Determines the location in the agenda   */
+/*    where a new activation should be placed for the breadth      */
+/*    strategy. Returns a pointer to the activation after which    */
+/*    the new activation should be placed (or NULL if the          */
+/*    activation should be placed at the beginning of the agenda). */
+/*******************************************************************/
+static Activation *PlaceBreadthActivation(
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   if (theGroup->last == NULL)
+     {
+      if (theGroup->prev == NULL)
+        { lastAct = NULL; }
+      else
+        { lastAct = theGroup->prev->last; }
+     }
+   else
+     { lastAct = theGroup->last; }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the activation is placed after       */
+   /* activations with a lessor timetag (yielding breadth     */
+   /* first traversal).                                       */
+   /*=========================================================*/
+
+   actPtr = theGroup->last;
+   while (actPtr != NULL)
+     {
+      if (timetag < actPtr->timetag)
+        {
+         if (actPtr == theGroup->first)
+           {
+            if (theGroup->prev == NULL)
+              { lastAct = NULL; }
+            else
+              { lastAct = theGroup->prev->last; }
+            break;
+           }
+         else
+           { actPtr = actPtr->prev; }
+        }
+      else
+        {
+         lastAct = actPtr;
+         break;
+        }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return lastAct;
+  }
+
+/*******************************************************************/
+/* PlaceLEXActivation: Determines the location in the agenda       */
+/*    where a new activation should be placed for the lex          */
+/*    strategy. Returns a pointer to the activation after which    */
+/*    the new activation should be placed (or NULL if the          */
+/*    activation should be placed at the beginning of the agenda). */
+/*******************************************************************/
+static Activation *PlaceLEXActivation(
+  Environment *theEnv,
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+   int flag;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*================================================*/
+   /* Look first at the very end of the group to see */
+   /* if the activation should be placed there.      */
+   /*================================================*/
+
+   actPtr = theGroup->last;
+   if (actPtr != NULL)
+     {
+      flag = ComparePartialMatches(theEnv,actPtr,newActivation);
+
+      if ((flag == LESS_THAN) ||
+          ((flag == EQUAL) &&  (timetag > actPtr->timetag)))
+        {
+         theGroup->last = newActivation;
+
+         return actPtr;
+        }
+     }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the OPS5 lex strategy is used for    */
+   /* determining placement.                                  */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      flag = ComparePartialMatches(theEnv,actPtr,newActivation);
+
+      if (flag == LESS_THAN)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else if (flag == GREATER_THAN)
+        { break; }
+      else /* flag == EQUAL */
+        {
+         if (timetag > actPtr->timetag)
+           {
+            lastAct = actPtr;
+            if (actPtr == theGroup->last)
+              { break; }
+            else
+              { actPtr = actPtr->next; }
+           }
+         else
+           { break; }
+        }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return lastAct;
+  }
+
+/*******************************************************************/
+/* PlaceMEAActivation: Determines the location in the agenda       */
+/*    where a new activation should be placed for the mea          */
+/*    strategy. Returns a pointer to the activation after which    */
+/*    the new activation should be placed (or NULL if the          */
+/*    activation should be placed at the beginning of the agenda). */
+/*******************************************************************/
+static Activation *PlaceMEAActivation(
+  Environment *theEnv,
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+   int flag;
+   unsigned long long cWhoset = 0, oWhoset = 0;
+   bool cSet, oSet;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*================================================*/
+   /* Look first at the very end of the group to see */
+   /* if the activation should be placed there.      */
+   /*================================================*/
+
+   actPtr = theGroup->last;
+   if (actPtr != NULL)
+     {
+      if (GetMatchingItem(newActivation,0) != NULL)
+        {
+         cWhoset = GetMatchingItem(newActivation,0)->timeTag;
+         cSet = true;
+        }
+      else
+        { cSet = false; }
+
+      if (GetMatchingItem(actPtr,0) != NULL)
+        {
+         oWhoset = GetMatchingItem(actPtr,0)->timeTag;
+         oSet = true;
+        }
+      else
+        { oSet = false; }
+
+      if ((cSet == false) && (oSet == false))
+        { flag = ComparePartialMatches(theEnv,actPtr,newActivation); }
+      else if ((cSet == true) && (oSet == false))
+        { flag = GREATER_THAN; }
+      else if ((cSet == false) && (oSet == true))
+        { flag = LESS_THAN; }
+      else if (oWhoset < cWhoset)
+        { flag = GREATER_THAN; }
+      else if (oWhoset > cWhoset)
+        { flag = LESS_THAN; }
+      else
+        { flag = ComparePartialMatches(theEnv,actPtr,newActivation); }
+
+      if ((flag == LESS_THAN) ||
+          ((flag == EQUAL) &&  (timetag > actPtr->timetag)))
+        {
+         theGroup->last = newActivation;
+
+         return actPtr;
+        }
+     }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the OPS5 mea strategy is used for    */
+   /* determining placement.                                  */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      cWhoset = 0;
+      oWhoset = 0;
+      if (GetMatchingItem(newActivation,0) != NULL)
+        { cWhoset = GetMatchingItem(newActivation,0)->timeTag; }
+
+      if (GetMatchingItem(actPtr,0) != NULL)
+        { oWhoset = GetMatchingItem(actPtr,0)->timeTag; }
+
+      if (oWhoset < cWhoset)
+        {
+         if (cWhoset > 0) flag = GREATER_THAN;
+         else flag = LESS_THAN;
+        }
+      else if (oWhoset > cWhoset)
+        {
+         if (oWhoset > 0) flag = LESS_THAN;
+         else flag = GREATER_THAN;
+        }
+      else
+        { flag = ComparePartialMatches(theEnv,actPtr,newActivation); }
+
+      if (flag == LESS_THAN)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else if (flag == GREATER_THAN)
+        { break; }
+      else /* flag == EQUAL */
+        {
+         if (timetag > actPtr->timetag)
+           {
+            lastAct = actPtr;
+            if (actPtr == theGroup->last)
+              { break; }
+            else
+              { actPtr = actPtr->next; }
+           }
+         else
+           { break; }
+        }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return lastAct;
+  }
+
+/*********************************************************************/
+/* PlaceComplexityActivation: Determines the location in the agenda  */
+/*    where a new activation should be placed for the complexity     */
+/*    strategy. Returns a pointer to the activation  after which the */
+/*    new activation should be placed (or NULL if the activation     */
+/*    should be placed at the beginning of the agenda).              */
+/*********************************************************************/
+static Activation *PlaceComplexityActivation(
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   unsigned int complexity;
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+
+   /*========================================*/
+   /* Set up initial information for search. */
+   /*========================================*/
+
+   timetag = newActivation->timetag;
+   complexity = newActivation->theRule->complexity;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the activation is placed before      */
+   /* activations of equal or lessor complexity.              */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      if (complexity < actPtr->theRule->complexity)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else if (complexity > actPtr->theRule->complexity)
+        { break; }
+      else if (timetag > actPtr->timetag)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else
+        { break; }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return lastAct;
+  }
+
+/*********************************************************************/
+/* PlaceSimplicityActivation: Determines the location in the agenda  */
+/*    where a new activation should be placed for the simplicity     */
+/*    strategy. Returns a pointer to the activation  after which the */
+/*    new activation should be placed (or NULL if the activation     */
+/*    should be placed at the beginning of the agenda).              */
+/*********************************************************************/
+static Activation *PlaceSimplicityActivation(
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   unsigned int complexity;
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   complexity = newActivation->theRule->complexity;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the activation is placed after       */
+   /* activations of equal or greater complexity.             */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      if (complexity > actPtr->theRule->complexity)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else if (complexity < actPtr->theRule->complexity)
+        { break; }
+      else if (timetag > actPtr->timetag)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else
+       { break; }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return(lastAct);
+  }
+
+/*******************************************************************/
+/* PlaceRandomActivation: Determines the location in the agenda    */
+/*    where a new activation should be placed for the random       */
+/*    strategy. Returns a pointer to the activation  after which   */
+/*    the new activation should be placed (or NULL if the          */
+/*    activation should be placed at the beginning of the agenda). */
+/*******************************************************************/
+static Activation *PlaceRandomActivation(
+  Activation *newActivation,
+  struct salienceGroup *theGroup)
+  {
+   int randomID;
+   unsigned long long timetag;
+   Activation *lastAct, *actPtr;
+
+   /*============================================*/
+   /* Set up initial information for the search. */
+   /*============================================*/
+
+   timetag = newActivation->timetag;
+   randomID = newActivation->randomID;
+   if (theGroup->prev == NULL)
+     { lastAct = NULL; }
+   else
+     { lastAct = theGroup->prev->last; }
+
+   /*=========================================================*/
+   /* Find the insertion point in the agenda. The activation  */
+   /* is placed before activations of lower salience and      */
+   /* after activations of higher salience. Among activations */
+   /* of equal salience, the placement of the activation is   */
+   /* determined through the generation of a random number.   */
+   /*=========================================================*/
+
+   actPtr = theGroup->first;
+   while (actPtr != NULL)
+     {
+      if (randomID > actPtr->randomID)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else if (randomID < actPtr->randomID)
+       { break; }
+      else if (timetag > actPtr->timetag)
+        {
+         lastAct = actPtr;
+         if (actPtr == theGroup->last)
+           { break; }
+         else
+           { actPtr = actPtr->next; }
+        }
+      else
+       { break; }
+     }
+
+   /*========================================*/
+   /* Update the salience group information. */
+   /*========================================*/
+
+   if ((lastAct == NULL) ||
+       ((theGroup->prev != NULL) && (theGroup->prev->last == lastAct)))
+     { theGroup->first = newActivation; }
+
+   if ((theGroup->last == NULL) || (theGroup->last == lastAct))
+     { theGroup->last = newActivation; }
+
+   /*===========================================*/
+   /* Return the insertion point in the agenda. */
+   /*===========================================*/
+
+   return(lastAct);
+  }
+
+/*********************************************************/
+/* SortPartialMatch: Creates an array of sorted timetags */
+/*    in ascending order from a partial match.           */
+/*********************************************************/
+static unsigned long long *SortPartialMatch(
+  Environment *theEnv,
+  struct partialMatch *binds)
+  {
+   unsigned long long *nbinds;
+   unsigned long long temp;
+   bool flag;
+   unsigned short j, k;
+
+   /*====================================================*/
+   /* Copy the array. Use 0 to represent the timetags of */
+   /* negated patterns. Patterns matching fact/instances */
+   /* should have timetags greater than 0.               */
+   /*====================================================*/
+
+   nbinds = (unsigned long long *) get_mem(theEnv,sizeof(long long) * binds->bcount);
+
+   for (j = 0; j < binds->bcount; j++)
+     {
+      if ((binds->binds[j].gm.theMatch != NULL) &&
+          (binds->binds[j].gm.theMatch->matchingItem != NULL))
+        { nbinds[j] = binds->binds[j].gm.theMatch->matchingItem->timeTag; }
+      else
+        { nbinds[j] = 0; }
+     }
+
+   /*=================*/
+   /* Sort the array. */
+   /*=================*/
+
+   for (flag = true, k = binds->bcount - 1;
+        flag == true;
+        k--)
+     {
+      flag = false;
+      for (j = 0 ; j < k ; j++)
+        {
+         if (nbinds[j] < nbinds[j + 1])
+           {
+            temp = nbinds[j];
+            nbinds[j] = nbinds[j+1];
+            nbinds[j+1] = temp;
+            flag = true;
+           }
+        }
+     }
+
+   /*===================*/
+   /* Return the array. */
+   /*===================*/
+
+   return nbinds;
+  }
+
+/**************************************************************************/
+/* ComparePartialMatches: Compares two activations using the lex conflict */
+/*   resolution strategy to determine which activation should be placed   */
+/*   first on the agenda. This lexicographic comparison function is used  */
+/*   for both the lex and mea strategies.                                 */
+/**************************************************************************/
+static int ComparePartialMatches(
+  Environment *theEnv,
+  Activation *actPtr,
+  Activation *newActivation)
+  {
+   unsigned cCount, oCount, mCount, i;
+   unsigned long long *basis1, *basis2;
+
+   /*=================================================*/
+   /* If the activation already on the agenda doesn't */
+   /* have a set of sorted timetags, then create one. */
+   /*=================================================*/
+
+   basis1 = SortPartialMatch(theEnv,newActivation->basis);
+   basis2 = SortPartialMatch(theEnv,actPtr->basis);
+
+   /*==============================================================*/
+   /* Determine the number of timetags in each of the activations. */
+   /* The number of timetags to be compared is the lessor of these */
+   /* two numbers.                                                 */
+   /*==============================================================*/
+
+   cCount = newActivation->basis->bcount;
+   oCount = actPtr->basis->bcount;
+
+   if (oCount > cCount) mCount = cCount;
+   else mCount = oCount;
+
+   /*===========================================================*/
+   /* Compare the sorted timetags one by one until there are no */
+   /* more timetags to compare or the timetags being compared   */
+   /* are not equal. If the timetags aren't equal, then the     */
+   /* activation containing the larger timetag is placed before */
+   /* the activation containing the smaller timetag.            */
+   /*===========================================================*/
+
+   for (i = 0 ; i < mCount ; i++)
+     {
+      if (basis1[i] < basis2[i])
+        {
+         rtn_mem(theEnv,sizeof(long long) * cCount,basis1);
+         rtn_mem(theEnv,sizeof(long long) * oCount,basis2);
+         return(LESS_THAN);
+        }
+      else if (basis1[i] > basis2[i])
+        {
+         rtn_mem(theEnv,sizeof(long long) * cCount,basis1);
+         rtn_mem(theEnv,sizeof(long long) * oCount,basis2);
+         return(GREATER_THAN);
+        }
+     }
+
+   rtn_mem(theEnv,sizeof(long long) * cCount,basis1);
+   rtn_mem(theEnv,sizeof(long long) * oCount,basis2);
+
+   /*==========================================================*/
+   /* If the sorted timetags are identical up to the number of */
+   /* timetags contained in the smaller partial match, then    */
+   /* the activation containing more timetags should be        */
+   /* placed before the activation containing fewer timetags.  */
+   /*==========================================================*/
+
+   if (cCount < oCount) return(LESS_THAN);
+   else if (cCount > oCount) return(GREATER_THAN);
+
+   /*=========================================================*/
+   /* If the sorted partial matches for both activations are  */
+   /* identical (containing the same number and values of     */
+   /* timetags), then the activation associated with the rule */
+   /* having the highest complexity is placed before the      */
+   /* other partial match.                                    */
+   /*=========================================================*/
+
+   if (newActivation->theRule->complexity < actPtr->theRule->complexity)
+     { return(LESS_THAN); }
+   else if (newActivation->theRule->complexity > actPtr->theRule->complexity)
+     { return(GREATER_THAN); }
+
+   /*================================================*/
+   /* The two partial matches are equal for purposes */
+   /* of placement on the agenda for the lex and mea */
+   /* conflict resolution strategies.                */
+   /*================================================*/
+
+   return(EQUAL);
+  }
+
+/***********************************/
+/* SetStrategy: C access routine   */
+/*   for the set-strategy command. */
+/***********************************/
+StrategyType SetStrategy(
+  Environment *theEnv,
+  StrategyType value)
+  {
+   StrategyType oldStrategy;
+
+   oldStrategy = AgendaData(theEnv)->Strategy;
+   AgendaData(theEnv)->Strategy = value;
+
+   if (oldStrategy != AgendaData(theEnv)->Strategy)
+     { ReorderAllAgendas(theEnv); }
+
+   return oldStrategy;
+  }
+
+/***********************************/
+/* GetStrategy: C access routine   */
+/*   for the get-strategy command. */
+/***********************************/
+StrategyType GetStrategy(
+  Environment *theEnv)
+  {
+   return AgendaData(theEnv)->Strategy;
+  }
+
+/********************************************/
+/* GetStrategyCommand: H/L access routine   */
+/*   for the get-strategy command.          */
+/********************************************/
+void GetStrategyCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   returnValue->lexemeValue = CreateSymbol(theEnv,GetStrategyName(GetStrategy(theEnv)));
+  }
+
+/********************************************/
+/* SetStrategyCommand: H/L access routine   */
+/*   for the set-strategy command.          */
+/********************************************/
+void SetStrategyCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   UDFValue theArg;
+   const char *argument;
+   StrategyType oldStrategy;
+
+   /*=======================*/
+   /* Set the return value. */
+   /*=======================*/
+
+   oldStrategy = GetStrategy(theEnv);
+   returnValue->lexemeValue = CreateSymbol(theEnv,GetStrategyName(oldStrategy));
+
+   /*=========================================*/
+   /* Check for the correct type of argument. */
+   /*=========================================*/
+
+   if (! UDFFirstArgument(context,SYMBOL_BIT,&theArg))
+     { return; }
+
+   /*=============================================*/
+   /* Set the strategy to the specified strategy. */
+   /*=============================================*/
+
+   argument = theArg.lexemeValue->contents;
+
+   if (strcmp(argument,"depth") == 0)
+     { SetStrategy(theEnv,DEPTH_STRATEGY); }
+   else if (strcmp(argument,"breadth") == 0)
+     { SetStrategy(theEnv,BREADTH_STRATEGY); }
+   else if (strcmp(argument,"lex") == 0)
+     { SetStrategy(theEnv,LEX_STRATEGY); }
+   else if (strcmp(argument,"mea") == 0)
+     { SetStrategy(theEnv,MEA_STRATEGY); }
+   else if (strcmp(argument,"complexity") == 0)
+     { SetStrategy(theEnv,COMPLEXITY_STRATEGY); }
+   else if (strcmp(argument,"simplicity") == 0)
+     { SetStrategy(theEnv,SIMPLICITY_STRATEGY); }
+   else if (strcmp(argument,"random") == 0)
+     { SetStrategy(theEnv,RANDOM_STRATEGY); }
+   else
+     {
+      UDFInvalidArgumentMessage(context,
+         "symbol with value depth, breadth, lex, mea, complexity, simplicity, or random");
+     }
+  }
+
+/**********************************************************/
+/* GetStrategyName: Given the integer value corresponding */
+/*   to a specified strategy, return a character string   */
+/*   of the strategy's name.                              */
+/**********************************************************/
+static const char *GetStrategyName(
+  StrategyType strategy)
+  {
+   const char *sname;
+
+   switch (strategy)
+     {
+      case DEPTH_STRATEGY:
+        sname = "depth";
+        break;
+      case BREADTH_STRATEGY:
+        sname = "breadth";
+        break;
+      case LEX_STRATEGY:
+        sname = "lex";
+        break;
+      case MEA_STRATEGY:
+        sname = "mea";
+        break;
+      case COMPLEXITY_STRATEGY:
+        sname = "complexity";
+        break;
+      case SIMPLICITY_STRATEGY:
+        sname = "simplicity";
+        break;
+      case RANDOM_STRATEGY:
+        sname = "random";
+        break;
+      default:
+        sname = "unknown";
+        break;
+     }
+
+   return(sname);
+  }
+
+#endif /* DEFRULE_CONSTRUCT */
+