clipsruby 0.0.2

data/ext/clipsruby/watch.c

@@ -0,0 +1,865 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*            CLIPS Version 6.40  08/25/16             */
+   /*                                                     */
+   /*                    WATCH MODULE                     */
+   /*******************************************************/
+
+
+/*************************************************************/
+/* Purpose: Support functions for the watch and unwatch      */
+/*   commands.                                               */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*      Brian Dantes                                         */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.23: Changed name of variable log to logName        */
+/*            because of Unix compiler warnings of shadowed  */
+/*            definitions.                                   */
+/*                                                           */
+/*      6.24: Renamed BOOLEAN macro type to intBool.         */
+/*                                                           */
+/*            Added EnvSetWatchItem function.                */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems (IBM_MCW,          */
+/*            MAC_MCW, and IBM_TBC).                         */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*      6.40: Added Env prefix to GetEvaluationError and     */
+/*            SetEvaluationError functions.                  */
+/*                                                           */
+/*            Pragma once and other inclusion changes.       */
+/*                                                           */
+/*            Added support for booleans with <stdbool.h>.   */
+/*                                                           */
+/*            Changed return values for router functions.    */
+/*                                                           */
+/*            Removed use of void pointers for specific      */
+/*            data structures.                               */
+/*                                                           */
+/*            ALLOW_ENVIRONMENT_GLOBALS no longer supported. */
+/*                                                           */
+/*            UDF redesign.                                  */
+/*                                                           */
+/*************************************************************/
+
+#include "setup.h"
+
+#if DEBUGGING_FUNCTIONS
+
+#include <stdio.h>
+#include <string.h>
+
+#include "argacces.h"
+#include "constant.h"
+#include "envrnmnt.h"
+#include "extnfunc.h"
+#include "memalloc.h"
+#include "router.h"
+
+#include "watch.h"
+
+/***************************************/
+/* LOCAL INTERNAL FUNCTION DEFINITIONS */
+/***************************************/
+
+   static WatchItemRecord        *ValidWatchItem(Environment *,const char *,bool *);
+   static void                    DeallocateWatchData(Environment *);
+
+/**********************************************/
+/* InitializeWatchData: Allocates environment */
+/*    data for watch items.                   */
+/**********************************************/
+void InitializeWatchData(
+  Environment *theEnv)
+  {
+   AllocateEnvironmentData(theEnv,WATCH_DATA,sizeof(struct watchData),DeallocateWatchData);
+  }
+
+/************************************************/
+/* DeallocateWatchData: Deallocates environment */
+/*    data for watch items.                     */
+/************************************************/
+static void DeallocateWatchData(
+  Environment *theEnv)
+  {
+   WatchItemRecord *tmpPtr, *nextPtr;
+
+   tmpPtr = WatchData(theEnv)->ListOfWatchItems;
+   while (tmpPtr != NULL)
+     {
+      nextPtr = tmpPtr->next;
+      rtn_struct(theEnv,watchItemRecord,tmpPtr);
+      tmpPtr = nextPtr;
+     }
+  }
+
+/*************************************************************/
+/* AddWatchItem: Adds an item to the list of watchable items */
+/*   that can be set using the watch and unwatch commands.   */
+/*   Returns false if the item is already in the list,       */
+/*   otherwise returns true.                                 */
+/*************************************************************/
+bool AddWatchItem(
+  Environment *theEnv,
+  const char *name,
+  int code,
+  bool *flag,
+  int priority,
+  bool (*accessFunc)(Environment *,int,bool,struct expr *),
+  bool (*printFunc)(Environment *,const char *,int,struct expr *))
+  {
+   WatchItemRecord *newPtr, *currentPtr, *lastPtr;
+
+   /*================================================================*/
+   /* Find the insertion point in the watchable items list to place  */
+   /* the new item. If the item is already in the list return false. */
+   /*================================================================*/
+
+   for (currentPtr = WatchData(theEnv)->ListOfWatchItems, lastPtr = NULL;
+        currentPtr != NULL;
+        currentPtr = currentPtr->next)
+     {
+      if (strcmp(currentPtr->name,name) == 0) return false;
+      if (priority < currentPtr->priority) lastPtr = currentPtr;
+     }
+
+   /*============================*/
+   /* Create the new watch item. */
+   /*============================*/
+
+   newPtr = get_struct(theEnv,watchItemRecord);
+   newPtr->name = name;
+   newPtr->flag = flag;
+   newPtr->code = code;
+   newPtr->priority = priority;
+   newPtr->accessFunc = accessFunc;
+   newPtr->printFunc = printFunc;
+
+   /*=================================================*/
+   /* Insert the new item in the list of watch items. */
+   /*=================================================*/
+
+   if (lastPtr == NULL)
+     {
+      newPtr->next = WatchData(theEnv)->ListOfWatchItems;
+      WatchData(theEnv)->ListOfWatchItems = newPtr;
+     }
+   else
+     {
+      newPtr->next = lastPtr->next;
+      lastPtr->next = newPtr;
+     }
+
+   /*==================================================*/
+   /* Return true to indicate the item has been added. */
+   /*==================================================*/
+
+   return true;
+  }
+
+/**************************************************/
+/* Watch: C access routine for the watch command. */
+/**************************************************/
+void Watch(
+  Environment *theEnv,
+  WatchItem item)
+  {
+   switch (item)
+     {
+      case ALL:
+        SetWatchItem(theEnv,"all",true,NULL);
+        break;
+
+      case FACTS:
+        SetWatchItem(theEnv,"facts",true,NULL);
+        break;
+        
+      case INSTANCES:
+        SetWatchItem(theEnv,"instances",true,NULL);
+        break;
+        
+      case SLOTS:
+        SetWatchItem(theEnv,"slots",true,NULL);
+        break;
+        
+      case RULES:
+        SetWatchItem(theEnv,"rules",true,NULL);
+        break;
+        
+      case ACTIVATIONS:
+        SetWatchItem(theEnv,"activations",true,NULL);
+        break;
+        
+      case MESSAGES:
+        SetWatchItem(theEnv,"messages",true,NULL);
+        break;
+        
+      case MESSAGE_HANDLERS:
+        SetWatchItem(theEnv,"message-handlers",true,NULL);
+        break;
+        
+      case GENERIC_FUNCTIONS:
+        SetWatchItem(theEnv,"generic-functions",true,NULL);
+        break;
+        
+      case METHODS:
+        SetWatchItem(theEnv,"methods",true,NULL);
+        break;
+        
+      case DEFFUNCTIONS:
+        SetWatchItem(theEnv,"deffunctions",true,NULL);
+        break;
+        
+      case COMPILATIONS:
+        SetWatchItem(theEnv,"compilations",true,NULL);
+        break;
+        
+      case STATISTICS:
+        SetWatchItem(theEnv,"statistics",true,NULL);
+        break;
+        
+      case GLOBALS:
+        SetWatchItem(theEnv,"globals",true,NULL);
+        break;
+        
+      case FOCUS:
+        SetWatchItem(theEnv,"focus",true,NULL);
+        break;
+     }
+  }
+
+/****************************************************/
+/* Unwatch: C access routine for the watch command. */
+/****************************************************/
+void Unwatch(
+  Environment *theEnv,
+  WatchItem item)
+  {
+   switch (item)
+     {
+      case ALL:
+        SetWatchItem(theEnv,"all",false,NULL);
+        break;
+
+      case FACTS:
+        SetWatchItem(theEnv,"facts",false,NULL);
+        break;
+        
+      case INSTANCES:
+        SetWatchItem(theEnv,"instances",false,NULL);
+        break;
+        
+      case SLOTS:
+        SetWatchItem(theEnv,"slots",false,NULL);
+        break;
+        
+      case RULES:
+        SetWatchItem(theEnv,"rules",false,NULL);
+        break;
+        
+      case ACTIVATIONS:
+        SetWatchItem(theEnv,"activations",false,NULL);
+        break;
+        
+      case MESSAGES:
+        SetWatchItem(theEnv,"messages",false,NULL);
+        break;
+        
+      case MESSAGE_HANDLERS:
+        SetWatchItem(theEnv,"message-handlers",false,NULL);
+        break;
+        
+      case GENERIC_FUNCTIONS:
+        SetWatchItem(theEnv,"generic-functions",false,NULL);
+        break;
+        
+      case METHODS:
+        SetWatchItem(theEnv,"methods",false,NULL);
+        break;
+        
+      case DEFFUNCTIONS:
+        SetWatchItem(theEnv,"deffunctions",false,NULL);
+        break;
+        
+      case COMPILATIONS:
+        SetWatchItem(theEnv,"compilations",false,NULL);
+        break;
+        
+      case STATISTICS:
+        SetWatchItem(theEnv,"statistics",false,NULL);
+        break;
+        
+      case GLOBALS:
+        SetWatchItem(theEnv,"globals",false,NULL);
+        break;
+        
+      case FOCUS:
+        SetWatchItem(theEnv,"focus",false,NULL);
+        break;
+     }
+  }
+
+/******************************************/
+/* GetWatchState: Returns the watch state */
+/*   for the specified watch item.        */
+/******************************************/
+bool GetWatchState(
+  Environment *theEnv,
+  WatchItem item)
+  {
+   switch (item)
+     {
+      case ALL:
+        return false;
+
+      case FACTS:
+        return (GetWatchItem(theEnv,"facts") == 1);
+        
+      case INSTANCES:
+        return (GetWatchItem(theEnv,"instances") == 1);
+        
+      case SLOTS:
+        return (GetWatchItem(theEnv,"slots") == 1);
+        
+      case RULES:
+        return (GetWatchItem(theEnv,"rules") == 1);
+        
+      case ACTIVATIONS:
+        return (GetWatchItem(theEnv,"activations") == 1);
+        
+      case MESSAGES:
+        return (GetWatchItem(theEnv,"messages") == 1);
+        
+      case MESSAGE_HANDLERS:
+        return (GetWatchItem(theEnv,"message-handlers") == 1);
+        
+      case GENERIC_FUNCTIONS:
+        return (GetWatchItem(theEnv,"generic-functions") == 1);
+        
+      case METHODS:
+        return (GetWatchItem(theEnv,"methods") == 1);
+        
+      case DEFFUNCTIONS:
+        return (GetWatchItem(theEnv,"deffunctions") == 1);
+        
+      case COMPILATIONS:
+        return (GetWatchItem(theEnv,"compilations") == 1);
+        
+      case STATISTICS:
+        return (GetWatchItem(theEnv,"statistics") == 1);
+        
+      case GLOBALS:
+        return (GetWatchItem(theEnv,"globals") == 1);
+        
+      case FOCUS:
+        return (GetWatchItem(theEnv,"focus") == 1);
+     }
+     
+   return false;
+  }
+
+/******************************************/
+/* SetWatchState: Returns the watch state */
+/*   for the specified watch item.        */
+/******************************************/
+void SetWatchState(
+  Environment *theEnv,
+  WatchItem item,
+  bool newState)
+  {
+   switch (item)
+     {
+      case ALL:
+        SetWatchItem(theEnv,"all",newState,NULL);
+        return;
+
+      case FACTS:
+        SetWatchItem(theEnv,"facts",newState,NULL);
+        return;
+        
+      case INSTANCES:
+        SetWatchItem(theEnv,"instances",newState,NULL);
+        return;
+        
+      case SLOTS:
+        SetWatchItem(theEnv,"slots",newState,NULL);
+        return;
+        
+      case RULES:
+        SetWatchItem(theEnv,"rules",newState,NULL);
+        return;
+        
+      case ACTIVATIONS:
+        SetWatchItem(theEnv,"activations",newState,NULL);
+        return;
+        
+      case MESSAGES:
+        SetWatchItem(theEnv,"messages",newState,NULL);
+        return;
+        
+      case MESSAGE_HANDLERS:
+        SetWatchItem(theEnv,"message-handlers",newState,NULL);
+        return;
+        
+      case GENERIC_FUNCTIONS:
+        SetWatchItem(theEnv,"generic-functions",newState,NULL);
+        return;
+        
+      case METHODS:
+        SetWatchItem(theEnv,"methods",newState,NULL);
+        return;
+        
+      case DEFFUNCTIONS:
+        SetWatchItem(theEnv,"deffunctions",newState,NULL);
+        return;
+        
+      case COMPILATIONS:
+        SetWatchItem(theEnv,"compilations",newState,NULL);
+        return;
+        
+      case STATISTICS:
+        SetWatchItem(theEnv,"statistics",newState,NULL);
+        return;
+        
+      case GLOBALS:
+        SetWatchItem(theEnv,"globals",newState,NULL);
+        return;
+        
+      case FOCUS:
+        SetWatchItem(theEnv,"focus",newState,NULL);
+        return;
+     }
+  }
+
+/********************************************************/
+/* WatchString: C access routine for the watch command. */
+/********************************************************/
+bool WatchString(
+  Environment *theEnv,
+  const char *itemName)
+  {
+   return SetWatchItem(theEnv,itemName,true,NULL);
+  }
+
+/************************************************************/
+/* UnwatchString: C access routine for the unwatch command. */
+/************************************************************/
+bool UnwatchString(
+  Environment *theEnv,
+  const char *itemName)
+  {
+   return SetWatchItem(theEnv,itemName,false,NULL);
+  }
+
+/********************************************************************/
+/* SetWatchItem: Sets the state of a specified watch item to either */
+/*   on or off. Returns true if the item was set, otherwise false.  */
+/********************************************************************/
+bool SetWatchItem(
+  Environment *theEnv,
+  const char *itemName,
+  bool newState,
+  struct expr *argExprs)
+  {
+   WatchItemRecord *wPtr;
+
+   /*===================================================*/
+   /* If the name of the watch item to set is all, then */
+   /* all watch items are set to the new state and true */
+   /* is returned.                                      */
+   /*===================================================*/
+
+   if (strcmp(itemName,"all") == 0)
+     {
+      for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
+        {
+         /*==============================================*/
+         /* If no specific arguments are specified, then */
+         /* set the global flag for the watch item.      */
+         /*==============================================*/
+
+         if (argExprs == NULL) *(wPtr->flag) = newState;
+
+         /*=======================================*/
+         /* Set flags for individual watch items. */
+         /*=======================================*/
+
+         if ((wPtr->accessFunc == NULL) ? false :
+             ((*wPtr->accessFunc)(theEnv,wPtr->code,newState,argExprs) == false))
+           {
+            SetEvaluationError(theEnv,true);
+            return false;
+           }
+        }
+      return true;
+     }
+
+   /*=================================================*/
+   /* Search for the watch item to be set in the list */
+   /* of watch items. If found, set the watch item to */
+   /* its new state and return true.                  */
+   /*=================================================*/
+
+   for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
+     {
+      if (strcmp(itemName,wPtr->name) == 0)
+        {
+         /*==============================================*/
+         /* If no specific arguments are specified, then */
+         /* set the global flag for the watch item.      */
+         /*==============================================*/
+
+         if (argExprs == NULL) *(wPtr->flag) = newState;
+
+         /*=======================================*/
+         /* Set flags for individual watch items. */
+         /*=======================================*/
+
+         if ((wPtr->accessFunc == NULL) ? false :
+             ((*wPtr->accessFunc)(theEnv,wPtr->code,newState,argExprs) == false))
+           {
+            SetEvaluationError(theEnv,true);
+            return false;
+           }
+
+         return true;
+        }
+     }
+
+   /*=================================================*/
+   /* If the specified item was not found in the list */
+   /* of watchable items then return false.           */
+   /*=================================================*/
+
+   return false;
+  }
+
+/****************************************************************/
+/* GetWatchItem: Gets the current state of the specified watch  */
+/*   item. Returns the state of the watch item (0 for off and 1 */
+/*   for on) if the watch item is found in the list of watch    */
+/*   items, otherwise -1 is returned.                           */
+/****************************************************************/
+int GetWatchItem(
+  Environment *theEnv,
+  const char *itemName)
+  {
+   WatchItemRecord *wPtr;
+
+   for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
+     {
+      if (strcmp(itemName,wPtr->name) == 0)
+        {
+         if (*(wPtr->flag))
+           { return 1; }
+         else
+           { return 0; }
+        }
+     }
+
+   return -1;
+  }
+
+/***************************************************************/
+/* ValidWatchItem: Returns true if the specified name is found */
+/*   in the list of watch items, otherwise returns false.      */
+/***************************************************************/
+static WatchItemRecord *ValidWatchItem(
+  Environment *theEnv,
+  const char *itemName,
+  bool *recognized)
+  {
+   WatchItemRecord *wPtr;
+
+   *recognized = true;
+   if (strcmp(itemName,"all") == 0)
+     return NULL;
+
+   for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
+     { if (strcmp(itemName,wPtr->name) == 0) return(wPtr); }
+
+   *recognized = false;
+   return NULL;
+  }
+
+/*************************************************************/
+/* GetNthWatchName: Returns the name associated with the nth */
+/*   item in the list of watchable items. If the nth item    */
+/*   does not exist, then NULL is returned.                  */
+/*************************************************************/
+const char *GetNthWatchName(
+  Environment *theEnv,
+  int whichItem)
+  {
+   int i;
+   WatchItemRecord *wPtr;
+
+   for (wPtr = WatchData(theEnv)->ListOfWatchItems, i = 1;
+        wPtr != NULL;
+        wPtr = wPtr->next, i++)
+     { if (i == whichItem) return(wPtr->name); }
+
+   return NULL;
+  }
+
+/***************************************************************/
+/* GetNthWatchValue: Returns the current state associated with */
+/*   the nth item in the list of watchable items. If the nth   */
+/*   item does not exist, then -1 is returned.                 */
+/***************************************************************/
+int GetNthWatchValue(
+  Environment *theEnv,
+  int whichItem)
+  {
+   int i;
+   WatchItemRecord *wPtr;
+
+   for (wPtr = WatchData(theEnv)->ListOfWatchItems, i = 1;
+        wPtr != NULL;
+        wPtr = wPtr->next, i++)
+     { if (i == whichItem) return((int) *(wPtr->flag)); }
+
+   return(-1);
+  }
+
+/**************************************/
+/* WatchCommand: H/L access routine   */
+/*   for the watch command.           */
+/**************************************/
+void WatchCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   UDFValue theValue;
+   const char *argument;
+   bool recognized;
+   WatchItemRecord *wPtr;
+
+   /*========================================*/
+   /* Determine which item is to be watched. */
+   /*========================================*/
+
+   if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue)) return;
+
+   argument = theValue.lexemeValue->contents;
+   wPtr = ValidWatchItem(theEnv,argument,&recognized);
+   if (recognized == false)
+     {
+      SetEvaluationError(theEnv,true);
+      UDFInvalidArgumentMessage(context,"watchable symbol");
+      return;
+     }
+
+   /*=================================================*/
+   /* Check to make sure extra arguments are allowed. */
+   /*=================================================*/
+
+   if (GetNextArgument(GetFirstArgument()) != NULL)
+     {
+      if ((wPtr == NULL) ? true : (wPtr->accessFunc == NULL))
+        {
+         SetEvaluationError(theEnv,true);
+         ExpectedCountError(theEnv,"watch",EXACTLY,1);
+         return;
+        }
+     }
+
+   /*=====================*/
+   /* Set the watch item. */
+   /*=====================*/
+
+   SetWatchItem(theEnv,argument,true,GetNextArgument(GetFirstArgument()));
+  }
+
+/****************************************/
+/* UnwatchCommand: H/L access routine   */
+/*   for the unwatch command.           */
+/****************************************/
+void UnwatchCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   UDFValue theValue;
+   const char *argument;
+   bool recognized;
+   WatchItemRecord *wPtr;
+
+   /*==========================================*/
+   /* Determine which item is to be unwatched. */
+   /*==========================================*/
+
+   if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue)) return;
+
+   argument = theValue.lexemeValue->contents;
+   wPtr = ValidWatchItem(theEnv,argument,&recognized);
+   if (recognized == false)
+     {
+      SetEvaluationError(theEnv,true);
+      UDFInvalidArgumentMessage(context,"watchable symbol");
+      return;
+     }
+
+   /*=================================================*/
+   /* Check to make sure extra arguments are allowed. */
+   /*=================================================*/
+
+   if (GetNextArgument(GetFirstArgument()) != NULL)
+     {
+      if ((wPtr == NULL) ? true : (wPtr->accessFunc == NULL))
+        {
+         SetEvaluationError(theEnv,true);
+         ExpectedCountError(theEnv,"unwatch",EXACTLY,1);
+         return;
+        }
+     }
+
+   /*=====================*/
+   /* Set the watch item. */
+   /*=====================*/
+
+   SetWatchItem(theEnv,argument,false,GetNextArgument(GetFirstArgument()));
+  }
+
+/************************************************/
+/* ListWatchItemsCommand: H/L access routines   */
+/*   for the list-watch-items command.          */
+/************************************************/
+void ListWatchItemsCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   WatchItemRecord *wPtr;
+   UDFValue theValue;
+   bool recognized;
+
+   /*=======================*/
+   /* List the watch items. */
+   /*=======================*/
+
+   if (GetFirstArgument() == NULL)
+     {
+      for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
+        {
+         WriteString(theEnv,STDOUT,wPtr->name);
+         if (*(wPtr->flag)) WriteString(theEnv,STDOUT," = on\n");
+         else WriteString(theEnv,STDOUT," = off\n");
+        }
+      return;
+     }
+
+   /*=======================================*/
+   /* Determine which item is to be listed. */
+   /*=======================================*/
+
+   if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue)) return;
+   wPtr = ValidWatchItem(theEnv,theValue.lexemeValue->contents,&recognized);
+   if ((recognized == false) || (wPtr == NULL))
+     {
+      SetEvaluationError(theEnv,true);
+      ExpectedTypeError1(theEnv,"list-watch-items",1,"'watchable symbol'");
+      return;
+     }
+
+   /*=================================================*/
+   /* Check to make sure extra arguments are allowed. */
+   /*=================================================*/
+
+   if ((wPtr->printFunc == NULL) &&
+       (GetNextArgument(GetFirstArgument()) != NULL))
+     {
+      SetEvaluationError(theEnv,true);
+      ExpectedCountError(theEnv,"list-watch-items",EXACTLY,1);
+      return;
+     }
+
+   /*====================================*/
+   /* List the status of the watch item. */
+   /*====================================*/
+
+   WriteString(theEnv,STDOUT,wPtr->name);
+   if (*(wPtr->flag)) WriteString(theEnv,STDOUT," = on\n");
+   else WriteString(theEnv,STDOUT," = off\n");
+
+   /*============================================*/
+   /* List the status of individual watch items. */
+   /*============================================*/
+
+   if (wPtr->printFunc != NULL)
+     {
+      if ((*wPtr->printFunc)(theEnv,STDOUT,wPtr->code,
+                             GetNextArgument(GetFirstArgument())) == false)
+        { SetEvaluationError(theEnv,true); }
+     }
+  }
+
+/*******************************************/
+/* GetWatchItemCommand: H/L access routine */
+/*   for the get-watch-item command.       */
+/*******************************************/
+void GetWatchItemCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   UDFValue theValue;
+   const char *argument;
+   bool recognized;
+
+   /*========================================*/
+   /* Determine which item is to be watched. */
+   /*========================================*/
+
+   if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue))
+     { return; }
+
+   argument = theValue.lexemeValue->contents;
+   ValidWatchItem(theEnv,argument,&recognized);
+   if (recognized == false)
+     {
+      SetEvaluationError(theEnv,true);
+      ExpectedTypeError1(theEnv,"get-watch-item",1,"'watchable symbol'");
+      returnValue->lexemeValue = FalseSymbol(theEnv);
+      return;
+     }
+
+   /*===========================*/
+   /* Get the watch item value. */
+   /*===========================*/
+
+   if (GetWatchItem(theEnv,argument) == 1)
+     { returnValue->lexemeValue = TrueSymbol(theEnv); }
+   else
+     { returnValue->lexemeValue = FalseSymbol(theEnv); }
+  }
+
+/*************************************************************/
+/* WatchFunctionDefinitions: Initializes the watch commands. */
+/*************************************************************/
+void WatchFunctionDefinitions(
+  Environment *theEnv)
+  {
+#if ! RUN_TIME
+   AddUDF(theEnv,"watch","v",1,UNBOUNDED,"*;y",WatchCommand,"WatchCommand",NULL);
+   AddUDF(theEnv,"unwatch","v",1,UNBOUNDED,"*;y",UnwatchCommand,"UnwatchCommand",NULL);
+   AddUDF(theEnv,"get-watch-item","b",1,1,"y",GetWatchItemCommand,"GetWatchItemCommand",NULL);
+   AddUDF(theEnv,"list-watch-items","v",0,UNBOUNDED,"*;y",ListWatchItemsCommand,"ListWatchItemsCommand",NULL);
+#endif
+  }
+
+#endif /* DEBUGGING_FUNCTIONS */
+