clipsruby 0.0.2

data/ext/clipsruby/globlcmp.c

@@ -0,0 +1,330 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*            CLIPS Version 6.40  07/30/16             */
+   /*                                                     */
+   /*            DEFGLOBAL CONSTRUCTS-TO-C MODULE         */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Implements the constructs-to-c feature for the   */
+/*    defglobal construct.                                   */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*      Brian L. Dantes                                      */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems (IBM_MCW,          */
+/*            MAC_MCW, and IBM_TBC).                         */
+/*                                                           */
+/*            Added support for path name argument to        */
+/*            constructs-to-c.                               */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*      6.40: Pragma once and other inclusion changes.       */
+/*                                                           */
+/*            Added support for booleans with <stdbool.h>.   */
+/*                                                           */
+/*            Removed use of void pointers for specific      */
+/*            data structures.                               */
+/*                                                           */
+/*************************************************************/
+
+#include "setup.h"
+
+#if DEFGLOBAL_CONSTRUCT && CONSTRUCT_COMPILER && (! RUN_TIME)
+
+#include <stdio.h>
+
+#include "conscomp.h"
+#include "envrnmnt.h"
+#include "globldef.h"
+
+#include "globlcmp.h"
+
+/***************************************/
+/* LOCAL INTERNAL FUNCTION DEFINITIONS */
+/***************************************/
+
+   static bool                    ConstructToCode(Environment *,const char *,const char *,char *,unsigned int,
+                                                  FILE *,unsigned int,unsigned int);
+   static void                    DefglobalToCode(Environment *,FILE *,Defglobal *,
+                                                 unsigned int,unsigned int,unsigned int);
+   static void                    DefglobalModuleToCode(Environment *,FILE *,Defmodule *,unsigned int,unsigned int,unsigned int);
+   static void                    CloseDefglobalFiles(Environment *,FILE *,FILE *,unsigned int);
+   static void                    BeforeDefglobalsToCode(Environment *);
+   static void                    InitDefglobalsCode(Environment *,FILE *,unsigned,unsigned);
+
+/***************************************************************/
+/* DefglobalCompilerSetup: Initializes the defglobal construct */
+/*    for use with the constructs-to-c command.                */
+/***************************************************************/
+void DefglobalCompilerSetup(
+  Environment *theEnv)
+  {
+   DefglobalData(theEnv)->DefglobalCodeItem =
+      AddCodeGeneratorItem(theEnv,"defglobal",0,BeforeDefglobalsToCode,
+                           InitDefglobalsCode,ConstructToCode,2);
+  }
+
+/**************************************************************/
+/* BeforeDefglobalsToCode: Assigns each defglobal a unique ID */
+/*   which will be used for pointer references when the data  */
+/*   structures are written to a file as C code               */
+/**************************************************************/
+static void BeforeDefglobalsToCode(
+  Environment *theEnv)
+  {
+   MarkConstructBsaveIDs(theEnv,DefglobalData(theEnv)->DefglobalModuleIndex);
+  }
+
+/*************************************************/
+/* InitDefglobalsCode: Writes out initialization */
+/*   code for defglobals for a run-time module.  */
+/*************************************************/
+static void InitDefglobalsCode(
+  Environment *theEnv,
+  FILE *initFP,
+  unsigned imageID,
+  unsigned maxIndices)
+  {
+#if MAC_XCD
+#pragma unused(maxIndices)
+#pragma unused(imageID)
+#pragma unused(theEnv)
+#endif
+   fprintf(initFP,"   DefglobalRunTimeInitialize(theEnv);\n");
+   fprintf(initFP,"   ResetDefglobals(theEnv,NULL);\n");
+  }
+
+/***********************************************************/
+/* ConstructToCode: Produces defglobal code for a run-time */
+/*   module created using the constructs-to-c function.    */
+/***********************************************************/
+static bool ConstructToCode(
+  Environment *theEnv,
+  const char *fileName,
+  const char *pathName,
+  char *fileNameBuffer,
+  unsigned int fileID,
+  FILE *headerFP,
+  unsigned int imageID,
+  unsigned int maxIndices)
+  {
+   unsigned int fileCount = 1;
+   Defmodule *theModule;
+   Defglobal *theDefglobal;
+   unsigned int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
+   unsigned int defglobalArrayCount = 0, defglobalArrayVersion = 1;
+   FILE *moduleFile = NULL, *defglobalFile = NULL;
+
+   /*================================================*/
+   /* Include the appropriate defglobal header file. */
+   /*================================================*/
+
+   fprintf(headerFP,"#include \"globldef.h\"\n");
+
+   /*===================================================================*/
+   /* Loop through all the modules and all the defglobals writing their */
+   /*  C code representation to the file as they are traversed.         */
+   /*===================================================================*/
+
+   for (theModule = GetNextDefmodule(theEnv,NULL);
+        theModule != NULL;
+        theModule = GetNextDefmodule(theEnv,theModule))
+     {
+      SetCurrentModule(theEnv,theModule);
+
+      moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
+                                    moduleArrayVersion,headerFP,
+                                    "struct defglobalModule",ModulePrefix(DefglobalData(theEnv)->DefglobalCodeItem),
+                                    false,NULL);
+
+      if (moduleFile == NULL)
+        {
+         CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
+         return false;
+        }
+
+      DefglobalModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
+      moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
+                                     maxIndices,NULL,NULL);
+
+      for (theDefglobal = GetNextDefglobal(theEnv,NULL);
+           theDefglobal != NULL;
+           theDefglobal = GetNextDefglobal(theEnv,theDefglobal))
+        {
+         defglobalFile = OpenFileIfNeeded(theEnv,defglobalFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
+                                         defglobalArrayVersion,headerFP,
+                                         "Defglobal",ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem),
+                                         false,NULL);
+         if (defglobalFile == NULL)
+           {
+            CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
+            return false;
+           }
+
+         DefglobalToCode(theEnv,defglobalFile,theDefglobal,imageID,maxIndices,moduleCount);
+         defglobalArrayCount++;
+         defglobalFile = CloseFileIfNeeded(theEnv,defglobalFile,&defglobalArrayCount,
+                                           &defglobalArrayVersion,maxIndices,NULL,NULL);
+        }
+
+      moduleCount++;
+      moduleArrayCount++;
+     }
+
+   CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
+
+   return true;
+  }
+
+/**********************************************************/
+/* CloseDefglobalFiles: Closes all of the C files created */
+/*   for defglobals. Called when an error occurs or when  */
+/*   the defglobals have all been written to the files.   */
+/**********************************************************/
+static void CloseDefglobalFiles(
+  Environment *theEnv,
+  FILE *moduleFile,
+  FILE *defglobalFile,
+  unsigned int maxIndices)
+  {
+   unsigned int count = maxIndices;
+   unsigned int arrayVersion = 0;
+
+   if (defglobalFile != NULL)
+     {
+      count = maxIndices;
+      CloseFileIfNeeded(theEnv,defglobalFile,&count,&arrayVersion,maxIndices,NULL,NULL);
+     }
+
+   if (moduleFile != NULL)
+     {
+      count = maxIndices;
+      CloseFileIfNeeded(theEnv,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
+     }
+  }
+
+/***********************************************************/
+/* DefglobalModuleToCode: Writes the C code representation */
+/*   of a single defglobal module to the specified file.   */
+/***********************************************************/
+static void DefglobalModuleToCode(
+  Environment *theEnv,
+  FILE *theFile,
+  Defmodule *theModule,
+  unsigned int imageID,
+  unsigned int maxIndices,
+  unsigned int moduleCount)
+  {
+#if MAC_XCD
+#pragma unused(moduleCount)
+#endif
+
+   fprintf(theFile,"{");
+
+   ConstructModuleToCode(theEnv,theFile,theModule,imageID,maxIndices,
+                                  DefglobalData(theEnv)->DefglobalModuleIndex,ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem));
+
+   fprintf(theFile,"}");
+  }
+
+/**********************************************************/
+/* DefglobalToCode: Writes the C code representation of a */
+/*   single defglobal construct to the specified file.    */
+/**********************************************************/
+static void DefglobalToCode(
+  Environment *theEnv,
+  FILE *theFile,
+  Defglobal *theDefglobal,
+  unsigned int imageID,
+  unsigned int maxIndices,
+  unsigned int moduleCount)
+  {
+   /*==================*/
+   /* Defglobal Header */
+   /*==================*/
+
+   fprintf(theFile,"{");
+
+   ConstructHeaderToCode(theEnv,theFile,&theDefglobal->header,imageID,maxIndices,
+                         moduleCount,ModulePrefix(DefglobalData(theEnv)->DefglobalCodeItem),
+                         ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem));
+
+   fprintf(theFile,",");
+
+   /*============================================*/
+   /* Watch Flag, In Scope Flag, and Busy Count. */
+   /*============================================*/
+
+   fprintf(theFile,"0,0,%ld,",theDefglobal->busyCount);
+
+   /*================*/
+   /* Current Value. */
+   /*================*/
+
+   fprintf(theFile,"{ { NULL } }");
+
+   /*=====================*/
+   /* Initial Expression. */
+   /*=====================*/
+
+   fprintf(theFile,",");
+   PrintHashedExpressionReference(theEnv,theFile,theDefglobal->initial,imageID,maxIndices);
+
+   fprintf(theFile,"}");
+  }
+
+/***************************************************************/
+/* DefglobalCModuleReference: Writes the C code representation */
+/*   of a reference to a defglobal module data structure.      */
+/***************************************************************/
+void DefglobalCModuleReference(
+  Environment *theEnv,
+  FILE *theFile,
+  unsigned long count,
+  unsigned int imageID,
+  unsigned int maxIndices)
+  {
+   fprintf(theFile,"MIHS &%s%u_%lu[%lu]",
+                      ModulePrefix(DefglobalData(theEnv)->DefglobalCodeItem),
+                      imageID,
+                      (count / maxIndices) + 1,
+                      (count % maxIndices));
+  }
+
+/******************************************************************/
+/* DefglobalCConstructReference: Writes the C code representation */
+/*   of a reference to a defglobal data structure.                */
+/******************************************************************/
+void DefglobalCConstructReference(
+  Environment *theEnv,
+  FILE *theFile,
+  Defglobal *theGlobal,
+  unsigned int imageID,
+  unsigned int maxIndices)
+  {
+
+   if (theGlobal == NULL)
+     { fprintf(theFile,"NULL"); }
+   else
+     {
+      fprintf(theFile,"&%s%u_%lu[%lu]",ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem),
+                      imageID,
+                      (theGlobal->header.bsaveID / maxIndices) + 1,
+                      theGlobal->header.bsaveID % maxIndices);
+     }
+
+  }
+
+#endif /* DEFGLOBAL_CONSTRUCT && CONSTRUCT_COMPILER && (! RUN_TIME) */
+
+

data/ext/clipsruby/globlcmp.h

@@ -0,0 +1,52 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*             CLIPS Version 6.40  07/30/16            */
+   /*                                                     */
+   /*       DEFGLOBAL CONSTRUCT COMPILER HEADER FILE      */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose:                                                  */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems (IBM_MCW,          */
+/*            MAC_MCW, and IBM_TBC).                         */
+/*                                                           */
+/*            Added support for path name argument to        */
+/*            constructs-to-c.                               */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*      6.40: Removed LOCALE definition.                     */
+/*                                                           */
+/*            Pragma once and other inclusion changes.       */
+/*                                                           */
+/*            Removed use of void pointers for specific      */
+/*            data structures.                               */
+/*                                                           */
+/*************************************************************/
+
+#ifndef _H_globlcmp
+
+#pragma once
+
+#define _H_globlcmp
+
+#include "globldef.h"
+
+   void                           DefglobalCompilerSetup(Environment *);
+   void                           DefglobalCModuleReference(Environment *,FILE *,unsigned long,unsigned int,unsigned int);
+   void                           DefglobalCConstructReference(Environment *,FILE *,Defglobal *,
+                                                               unsigned int,unsigned int);
+
+#endif /* _H_globlcmp */
+

data/ext/clipsruby/globlcom.c

@@ -0,0 +1,289 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*            CLIPS Version 6.40  10/28/20             */
+   /*                                                     */
+   /*              DEFGLOBAL COMMANDS MODULE              */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Provides the show-defglobals, set-reset-globals, */
+/*   and get-reset-globals commands.                         */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.23: Correction for FalseSymbol/TrueSymbol. DR0859  */
+/*                                                           */
+/*      6.24: Renamed BOOLEAN macro type to intBool.         */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems (IBM_MCW and       */
+/*            MAC_MCW).                                      */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*      6.32: Fixed embedded reset of error flags.           */
+/*                                                           */
+/*      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 "setup.h"
+
+#if DEFGLOBAL_CONSTRUCT
+
+#include "argacces.h"
+#include "envrnmnt.h"
+#include "extnfunc.h"
+#include "globldef.h"
+#include "prntutil.h"
+#include "router.h"
+
+#include "globlcom.h"
+
+/***************************************/
+/* LOCAL INTERNAL FUNCTION DEFINITIONS */
+/***************************************/
+
+#if DEBUGGING_FUNCTIONS
+   static void                       PrintDefglobalValueForm(Environment *,const char *,Defglobal *);
+#endif
+
+/************************************************************/
+/* DefglobalCommandDefinitions: Defines defglobal commands. */
+/************************************************************/
+void DefglobalCommandDefinitions(
+  Environment *theEnv)
+  {
+#if ! RUN_TIME
+   AddUDF(theEnv,"set-reset-globals","b",1,1,NULL,SetResetGlobalsCommand,"SetResetGlobalsCommand",NULL);
+   AddUDF(theEnv,"get-reset-globals","b",0,0,NULL,GetResetGlobalsCommand,"GetResetGlobalsCommand",NULL);
+
+#if DEBUGGING_FUNCTIONS
+   AddUDF(theEnv,"show-defglobals","v",0,1,"y",ShowDefglobalsCommand,"ShowDefglobalsCommand",NULL);
+#endif
+
+#else
+#if MAC_XCD
+#pragma unused(theEnv)
+#endif
+#endif
+  }
+
+/************************************************/
+/* SetResetGlobalsCommand: H/L access routine   */
+/*   for the get-reset-globals command.         */
+/************************************************/
+void SetResetGlobalsCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   bool oldValue;
+   UDFValue theArg;
+
+   /*===========================================*/
+   /* Remember the old value of this attribute. */
+   /*===========================================*/
+
+   oldValue = GetResetGlobals(theEnv);
+
+   /*===========================================*/
+   /* Determine the new value of the attribute. */
+   /*===========================================*/
+
+   if (! UDFFirstArgument(context,ANY_TYPE_BITS,&theArg))
+     { return; }
+
+   if (theArg.value == FalseSymbol(theEnv))
+     { SetResetGlobals(theEnv,false); }
+   else
+     { SetResetGlobals(theEnv,true); }
+
+   /*========================================*/
+   /* Return the old value of the attribute. */
+   /*========================================*/
+
+   returnValue->lexemeValue = CreateBoolean(theEnv,oldValue);
+  }
+
+/****************************************/
+/* SetResetGlobals: C access routine */
+/*   for the set-reset-globals command. */
+/****************************************/
+bool SetResetGlobals(
+  Environment *theEnv,
+  bool value)
+  {
+   bool ov;
+
+   ov = DefglobalData(theEnv)->ResetGlobals;
+   DefglobalData(theEnv)->ResetGlobals = value;
+   return(ov);
+  }
+
+/************************************************/
+/* GetResetGlobalsCommand: H/L access routine   */
+/*   for the get-reset-globals command.         */
+/************************************************/
+void GetResetGlobalsCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   returnValue->lexemeValue = CreateBoolean(theEnv,GetResetGlobals(theEnv));
+  }
+
+/****************************************/
+/* GetResetGlobals: C access routine    */
+/*   for the get-reset-globals command. */
+/****************************************/
+bool GetResetGlobals(
+  Environment *theEnv)
+  {
+   return(DefglobalData(theEnv)->ResetGlobals);
+  }
+
+#if DEBUGGING_FUNCTIONS
+
+/***********************************************/
+/* ShowDefglobalsCommand: H/L access routine   */
+/*   for the show-defglobals command.          */
+/***********************************************/
+void ShowDefglobalsCommand(
+  Environment *theEnv,
+  UDFContext *context,
+  UDFValue *returnValue)
+  {
+   Defmodule *theModule;
+   unsigned int numArgs;
+   bool error;
+
+   numArgs = UDFArgumentCount(context);
+
+   if (numArgs == 1)
+     {
+      theModule = GetModuleName(context,1,&error);
+      if (error) return;
+     }
+   else
+     { theModule = GetCurrentModule(theEnv); }
+
+   ShowDefglobals(theEnv,STDOUT,theModule);
+  }
+
+/**************************************/
+/* ShowDefglobals: C access routine   */
+/*   for the show-defglobals command. */
+/**************************************/
+void ShowDefglobals(
+  Environment *theEnv,
+  const char *logicalName,
+  Defmodule *theModule)
+  {
+   ConstructHeader *constructPtr;
+   bool allModules = false;
+   struct defmoduleItemHeader *theModuleItem;
+   
+   /*=====================================*/
+   /* If embedded, clear the error flags. */
+   /*=====================================*/
+   
+   if (EvaluationData(theEnv)->CurrentExpression == NULL)
+     { ResetErrorFlags(theEnv); }
+     
+   /*=======================================*/
+   /* If the module specified is NULL, then */
+   /* list all constructs in all modules.   */
+   /*=======================================*/
+
+   if (theModule == NULL)
+     {
+      theModule = GetNextDefmodule(theEnv,NULL);
+      allModules = true;
+     }
+
+   /*======================================================*/
+   /* Print out the constructs in the specified module(s). */
+   /*======================================================*/
+
+   for (;
+        theModule != NULL;
+        theModule = GetNextDefmodule(theEnv,theModule))
+     {
+      /*===========================================*/
+      /* Print the module name before every group  */
+      /* of defglobals listed if we're listing the */
+      /* defglobals from every module.             */
+      /*===========================================*/
+
+      if (allModules)
+        {
+         WriteString(theEnv,logicalName,DefmoduleName(theModule));
+         WriteString(theEnv,logicalName,":\n");
+        }
+
+      /*=====================================*/
+      /* Print every defglobal in the module */
+      /* currently being examined.           */
+      /*=====================================*/
+
+      theModuleItem = (struct defmoduleItemHeader *) GetModuleItem(theEnv,theModule,DefglobalData(theEnv)->DefglobalModuleIndex);
+
+      for (constructPtr = theModuleItem->firstItem;
+           constructPtr != NULL;
+           constructPtr = constructPtr->next)
+        {
+         if (EvaluationData(theEnv)->HaltExecution == true) return;
+
+         if (allModules) WriteString(theEnv,logicalName,"   ");
+         PrintDefglobalValueForm(theEnv,logicalName,(Defglobal *) constructPtr);
+         WriteString(theEnv,logicalName,"\n");
+        }
+
+      /*===================================*/
+      /* If we're only listing the globals */
+      /* for one module, then return.      */
+      /*===================================*/
+
+      if (! allModules) return;
+     }
+  }
+
+/*****************************************************/
+/* PrintDefglobalValueForm: Prints the value form of */
+/*   a defglobal (the current value). For example,   */
+/*   ?*x* = 3                                        */
+/*****************************************************/
+static void PrintDefglobalValueForm(
+  Environment *theEnv,
+  const char *logicalName,
+  Defglobal *theGlobal)
+  {
+   WriteString(theEnv,logicalName,"?*");
+   WriteString(theEnv,logicalName,theGlobal->header.name->contents);
+   WriteString(theEnv,logicalName,"* = ");
+   WriteCLIPSValue(theEnv,logicalName,&theGlobal->current);
+  }
+
+#endif /* DEBUGGING_FUNCTIONS */
+
+#endif /* DEFGLOBAL_CONSTRUCT */
+