Ejemplo n.º 1
0
globle void InitializeAgenda(
    void *theEnv)
{
    AllocateEnvironmentData(theEnv,AGENDA_DATA,sizeof(struct agendaData),NULL);

    AgendaData(theEnv)->SalienceEvaluation = WHEN_DEFINED;

    AgendaData(theEnv)->Strategy = DEFAULT_STRATEGY;

    EnvAddClearFunction(theEnv,(char*)"agenda",AgendaClearFunction,0);
#if DEBUGGING_FUNCTIONS
    AddWatchItem(theEnv,(char*)"activations",1,&AgendaData(theEnv)->WatchActivations,40,DefruleWatchAccess,DefruleWatchPrint);
#endif
#if ! RUN_TIME
    EnvDefineFunction2(theEnv,(char*)"refresh", 'v', PTIEF RefreshCommand, (char*)"RefreshCommand", (char*)"11w");

    EnvDefineFunction2(theEnv,(char*)"refresh-agenda",'v',
                       PTIEF RefreshAgendaCommand,
                       (char*)"RefreshAgendaCommand",
                       (char*)"01w");
    EnvDefineFunction2(theEnv,(char*)"get-salience-evaluation",'w',
                       PTIEF GetSalienceEvaluationCommand,
                       (char*)"GetSalienceEvaluationCommand",
                       (char*)"00");
    EnvDefineFunction2(theEnv,(char*)"set-salience-evaluation",'w',
                       PTIEF SetSalienceEvaluationCommand,
                       (char*)"SetSalienceEvaluationCommand",
                       (char*)"11w");

#if DEBUGGING_FUNCTIONS
    EnvDefineFunction2(theEnv,(char*)"agenda", 'v', PTIEF AgendaCommand, (char*)"AgendaCommand", (char*)"01w");
#endif
#endif
}
Ejemplo n.º 2
0
globle intBool EnvSetSalienceEvaluation(
    void *theEnv,
    int value)
{
    int ov;

    ov = AgendaData(theEnv)->SalienceEvaluation;
    AgendaData(theEnv)->SalienceEvaluation = value;
    return(ov);
}
Ejemplo n.º 3
0
globle int EnvSetStrategy(
  void *theEnv,
  int value)
  {
   int oldStrategy;

   oldStrategy = AgendaData(theEnv)->Strategy;
   AgendaData(theEnv)->Strategy = value;

   if (oldStrategy != AgendaData(theEnv)->Strategy) EnvReorderAgenda(theEnv,NULL);

   return(oldStrategy);
  }
Ejemplo n.º 4
0
static void UpdateDefrule(
  void *theEnv,
  void *buf,
  long obji)
  {
   struct bsaveDefrule *br;

   br = (struct bsaveDefrule *) buf;
   UpdateConstructHeader(theEnv,&br->header,&DefruleBinaryData(theEnv)->DefruleArray[obji].header,
                         (int) sizeof(struct defruleModule),(void *) DefruleBinaryData(theEnv)->ModuleArray,
                         (int) sizeof(struct defrule),(void *) DefruleBinaryData(theEnv)->DefruleArray);

   DefruleBinaryData(theEnv)->DefruleArray[obji].dynamicSalience = ExpressionPointer(br->dynamicSalience);

   DefruleBinaryData(theEnv)->DefruleArray[obji].actions = ExpressionPointer(br->actions);
   DefruleBinaryData(theEnv)->DefruleArray[obji].logicalJoin = BloadJoinPointer(br->logicalJoin);
   DefruleBinaryData(theEnv)->DefruleArray[obji].lastJoin = BloadJoinPointer(br->lastJoin);
   DefruleBinaryData(theEnv)->DefruleArray[obji].disjunct = BloadDefrulePointer(DefruleBinaryData(theEnv)->DefruleArray,br->disjunct);
   DefruleBinaryData(theEnv)->DefruleArray[obji].salience = br->salience;
   DefruleBinaryData(theEnv)->DefruleArray[obji].localVarCnt = br->localVarCnt;
   DefruleBinaryData(theEnv)->DefruleArray[obji].complexity = br->complexity;
   DefruleBinaryData(theEnv)->DefruleArray[obji].autoFocus = br->autoFocus;
   DefruleBinaryData(theEnv)->DefruleArray[obji].executing = 0;
   DefruleBinaryData(theEnv)->DefruleArray[obji].afterBreakpoint = 0;
#if DEBUGGING_FUNCTIONS
   DefruleBinaryData(theEnv)->DefruleArray[obji].watchActivation = AgendaData(theEnv)->WatchActivations;
   DefruleBinaryData(theEnv)->DefruleArray[obji].watchFiring = DefruleData(theEnv)->WatchRules;
#endif
  }
Ejemplo n.º 5
0
globle intBool DetachActivation(
  void *theEnv,
  void *vTheActivation)
  {
   struct defruleModule *theModuleItem;
   struct activation *theActivation = (struct activation *) vTheActivation;

   /*============================*/
   /* A NULL pointer is invalid. */
   /*============================*/

   if (theActivation == NULL) SystemError(theEnv,"AGENDA",1);

   /*====================================*/
   /* Determine the module of the agenda */
   /* in which the activation is stored. */
   /*====================================*/

   theModuleItem = (struct defruleModule *) theActivation->theRule->header.whichModule;

   RemoveActivationFromGroup(theEnv,theActivation,theModuleItem);

   /*========================================================*/
   /* If the activation is the top activation on the agenda, */
   /* then update the module pointer to agenda.              */
   /*========================================================*/

   if (theActivation == theModuleItem->agenda)
     { theModuleItem->agenda = theActivation->next; }

   /*==================================================*/
   /* Update the pointers in the preceding activation. */
   /*==================================================*/

   if (theActivation->prev != NULL)
     { theActivation->prev->next = theActivation->next; }

   /*==================================================*/
   /* Update the pointers in the following activation. */
   /*==================================================*/

   if (theActivation->next != NULL)
     { theActivation->next->prev = theActivation->prev; }

   /*=================================================*/
   /* Update the pointers in the detached activation. */
   /*=================================================*/

   theActivation->prev = NULL;
   theActivation->next = NULL;

   /*=============================*/
   /* Mark the agenda as changed. */
   /*=============================*/

   AgendaData(theEnv)->AgendaChanged = TRUE;

   return(TRUE);
  }
Ejemplo n.º 6
0
globle void *SetStrategyCommand(
  void *theEnv)
  {
   DATA_OBJECT argPtr;
   char *argument;
   int oldStrategy;

   oldStrategy = AgendaData(theEnv)->Strategy;

   /*=====================================================*/
   /* Check for the correct number and type of arguments. */
   /*=====================================================*/

   if (EnvArgCountCheck(theEnv,"set-strategy",EXACTLY,1) == -1)
     { return((SYMBOL_HN *) EnvAddSymbol(theEnv,GetStrategyName(EnvGetStrategy(theEnv)))); }

   if (EnvArgTypeCheck(theEnv,"set-strategy",1,SYMBOL,&argPtr) == FALSE)
     { return((SYMBOL_HN *) EnvAddSymbol(theEnv,GetStrategyName(EnvGetStrategy(theEnv)))); }

   argument = DOToString(argPtr);

   /*=============================================*/
   /* Set the strategy to the specified strategy. */
   /*=============================================*/

   if (strcmp(argument,"depth") == 0)
     { EnvSetStrategy(theEnv,DEPTH_STRATEGY); }
   else if (strcmp(argument,"breadth") == 0)
     { EnvSetStrategy(theEnv,BREADTH_STRATEGY); }
   else if (strcmp(argument,"lex") == 0)
     { EnvSetStrategy(theEnv,LEX_STRATEGY); }
   else if (strcmp(argument,"mea") == 0)
     { EnvSetStrategy(theEnv,MEA_STRATEGY); }
   else if (strcmp(argument,"complexity") == 0)
     { EnvSetStrategy(theEnv,COMPLEXITY_STRATEGY); }
   else if (strcmp(argument,"simplicity") == 0)
     { EnvSetStrategy(theEnv,SIMPLICITY_STRATEGY); }
   else if (strcmp(argument,"random") == 0)
     { EnvSetStrategy(theEnv,RANDOM_STRATEGY); }
   else
     {
      ExpectedTypeError1(theEnv,"set-strategy",1,
      "symbol with value depth, breadth, lex, mea, complexity, simplicity, or random");
      return((SYMBOL_HN *) EnvAddSymbol(theEnv,GetStrategyName(EnvGetStrategy(theEnv))));
     }

   /*=======================================*/
   /* Return the old value of the strategy. */
   /*=======================================*/

   return((SYMBOL_HN *) EnvAddSymbol(theEnv,GetStrategyName(oldStrategy)));
  }
Ejemplo n.º 7
0
globle intBool MoveActivationToTop(
    void *theEnv,
    void *vtheActivation)
{
    struct activation *prevPtr;
    struct activation *theActivation = (struct activation *) vtheActivation;
    struct defruleModule *theModuleItem;

    /*====================================*/
    /* Determine the module of the agenda */
    /* in which the activation is stored. */
    /*====================================*/

    theModuleItem = (struct defruleModule *) theActivation->theRule->header.whichModule;

    /*============================================*/
    /* If the activation is already at the top of */
    /* the agenda, then nothing needs to be done. */
    /*============================================*/

    if (theActivation == theModuleItem->agenda) return(FALSE);

    /*=================================================*/
    /* Update the pointers of the activation preceding */
    /* and following the activation being moved.       */
    /*=================================================*/

    prevPtr = theActivation->prev;
    prevPtr->next = theActivation->next;
    if (theActivation->next != NULL) theActivation->next->prev = prevPtr;

    /*=======================================================*/
    /* Move the activation and then update its pointers, the */
    /* pointers of the activation following it, and the      */
    /* module pointer to the top activation on the agenda.   */
    /*=======================================================*/

    theActivation->next = theModuleItem->agenda;
    theModuleItem->agenda->prev = theActivation;
    theActivation->prev = NULL;
    theModuleItem->agenda = theActivation;

    /*=============================*/
    /* Mark the agenda as changed. */
    /*=============================*/

    AgendaData(theEnv)->AgendaChanged = TRUE;

    return(TRUE);
}
Ejemplo n.º 8
0
globle unsigned long GetNumberOfActivations(
    void *theEnv)
{
    return(AgendaData(theEnv)->NumberOfActivations);
}
Ejemplo n.º 9
0
globle void EnvSetAgendaChanged(
    void *theEnv,
    int value)
{
    AgendaData(theEnv)->AgendaChanged = value;
}
Ejemplo n.º 10
0
globle int EnvGetAgendaChanged(
    void *theEnv)
{
    return(AgendaData(theEnv)->AgendaChanged);
}
Ejemplo n.º 11
0
static void AgendaClearFunction(
    void *theEnv)
{
    AgendaData(theEnv)->CurrentTimetag = 0;
}
Ejemplo n.º 12
0
globle void RemoveActivation(
    void *theEnv,
    void *vTheActivation,
    int updateAgenda,
    int updateLinks)
{
    struct defruleModule *theModuleItem;
    struct activation *theActivation = (struct activation *) vTheActivation;

    /*====================================*/
    /* Determine the module of the agenda */
    /* in which the activation is stored. */
    /*====================================*/

    theModuleItem = (struct defruleModule *) theActivation->theRule->header.whichModule;

    /*=================================*/
    /* Update the agenda if necessary. */
    /*=================================*/

    if (updateAgenda == TRUE)
    {
        RemoveActivationFromGroup(theEnv,theActivation,theModuleItem);

        /*===============================================*/
        /* Update the pointer links between activations. */
        /*===============================================*/

        if (theActivation->prev == NULL)
        {
            theModuleItem->agenda = theModuleItem->agenda->next;
            if (theModuleItem->agenda != NULL) theModuleItem->agenda->prev = NULL;
        }
        else
        {
            theActivation->prev->next = theActivation->next;
            if (theActivation->next != NULL)
            {
                theActivation->next->prev = theActivation->prev;
            }
        }

        /*===================================*/
        /* Indicate removal of activation if */
        /* activations are being watched.    */
        /*===================================*/

#if DEBUGGING_FUNCTIONS
        if (theActivation->theRule->watchActivation)
        {
            EnvPrintRouter(theEnv,WTRACE,(char*)"<== Activation ");
            PrintActivation(theEnv,WTRACE,(void *) theActivation);
            EnvPrintRouter(theEnv,WTRACE,(char*)"\n");
        }
#endif

        /*=============================*/
        /* Mark the agenda as changed. */
        /*=============================*/

        AgendaData(theEnv)->AgendaChanged = TRUE;
    }

    /*============================================*/
    /* Update join and agenda links if necessary. */
    /*============================================*/

    if ((updateLinks == TRUE) && (theActivation->basis != NULL))
    {
        theActivation->basis->marker = NULL;
    }

    /*================================================*/
    /* Return the activation to the free memory pool. */
    /*================================================*/

    AgendaData(theEnv)->NumberOfActivations--;

    rtn_struct(theEnv,activation,theActivation);
}
Ejemplo n.º 13
0
globle void AddActivation(
    void *theEnv,
    void *vTheRule,
    void *vBinds)
{
    struct activation *newActivation;
    struct defrule *theRule = (struct defrule *) vTheRule;
    struct partialMatch *binds = (struct partialMatch *) vBinds;
    struct defruleModule *theModuleItem;
    struct salienceGroup *theGroup;

    /*=======================================*/
    /* Focus on the module if the activation */
    /* is from an auto-focus rule.           */
    /*=======================================*/

    if (theRule->autoFocus)
    {
        EnvFocus(theEnv,(void *) theRule->header.whichModule->theModule);
    }

    /*=======================================================*/
    /* Create the activation. The activation stores pointers */
    /* to its associated partial match and defrule. The      */
    /* activation is given a time tag, its salience is       */
    /* evaluated, and it is assigned a random number for use */
    /* with the random conflict resolution strategy.         */
    /*=======================================================*/

    newActivation = get_struct(theEnv,activation);
    newActivation->theRule = theRule;
    newActivation->basis = binds;
    newActivation->timetag = AgendaData(theEnv)->CurrentTimetag++;
    newActivation->salience = EvaluateSalience(theEnv,theRule);

    newActivation->randomID = genrand();
    newActivation->prev = NULL;
    newActivation->next = NULL;

    AgendaData(theEnv)->NumberOfActivations++;

    /*=======================================================*/
    /* Point the partial match to the activation to complete */
    /* the link between the join network and the agenda.     */
    /*=======================================================*/

    binds->marker = (void *) newActivation;

    /*====================================================*/
    /* If activations are being watch, display a message. */
    /*====================================================*/

#if DEBUGGING_FUNCTIONS
    if (newActivation->theRule->watchActivation)
    {
        EnvPrintRouter(theEnv,WTRACE,(char*)"==> Activation ");
        PrintActivation(theEnv,WTRACE,(void *) newActivation);
        EnvPrintRouter(theEnv,WTRACE,(char*)"\n");
    }
#endif

    /*=====================================*/
    /* Place the activation on the agenda. */
    /*=====================================*/

    theModuleItem = (struct defruleModule *) theRule->header.whichModule;

    theGroup = ReuseOrCreateSalienceGroup(theEnv,theModuleItem,newActivation->salience);

    PlaceActivation(theEnv,&(theModuleItem->agenda),newActivation,theGroup);
}
Ejemplo n.º 14
0
globle intBool EnvGetSalienceEvaluation(
    void *theEnv)
{
    return(AgendaData(theEnv)->SalienceEvaluation);
}
Ejemplo n.º 15
0
globle int EnvGetStrategy(
  void *theEnv)
  {
   return(AgendaData(theEnv)->Strategy);
  }
Ejemplo n.º 16
0
globle void PlaceActivation(
  void *theEnv,
  ACTIVATION **whichAgenda,
  ACTIVATION *newActivation)
  {
   ACTIVATION *placeAfter = NULL;

   /*================================================*/
   /* Set the flag which indicates that a change has */
   /* been made to the agenda.                       */
   /*================================================*/

   EnvSetAgendaChanged(theEnv,TRUE);

   /*=============================================*/
   /* Determine the location where the activation */
   /* should be placed in the agenda based on the */
   /* current conflict resolution strategy.       */
   /*==============================================*/

#if ! CONFLICT_RESOLUTION_STRATEGIES
   if (*whichAgenda != NULL) placeAfter = PlaceDepthActivation(*whichAgenda,newActivation);
#else
   if (*whichAgenda != NULL) switch (AgendaData(theEnv)->Strategy)
     {
      case DEPTH_STRATEGY:
        placeAfter = PlaceDepthActivation(*whichAgenda,newActivation);
        break;

      case BREADTH_STRATEGY:
        placeAfter = PlaceBreadthActivation(*whichAgenda,newActivation);
        break;

      case LEX_STRATEGY:
        placeAfter = PlaceLEXActivation(theEnv,*whichAgenda,newActivation);
        break;

      case MEA_STRATEGY:
        placeAfter = PlaceMEAActivation(theEnv,*whichAgenda,newActivation);
        break;

      case COMPLEXITY_STRATEGY:
        placeAfter = PlaceComplexityActivation(*whichAgenda,newActivation);
        break;

      case SIMPLICITY_STRATEGY:
        placeAfter = PlaceSimplicityActivation(*whichAgenda,newActivation);
        break;

      case RANDOM_STRATEGY:
        placeAfter = PlaceRandomActivation(*whichAgenda,newActivation);
        break;
     }
#endif

   /*==============================================================*/
   /* 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; }
     }
  }