clipsruby 0.0.2

data/ext/clipsruby/memalloc.c

@@ -0,0 +1,481 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*            CLIPS Version 6.41  05/24/21             */
+   /*                                                     */
+   /*                    MEMORY MODULE                    */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Memory allocation routines.                      */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*      Brian L. Dantes                                      */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.24: Removed HaltExecution check from the           */
+/*            EnvReleaseMem function. DR0863                 */
+/*                                                           */
+/*            Renamed BOOLEAN macro type to intBool.         */
+/*                                                           */
+/*            Corrected code to remove compiler warnings.    */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems.                   */
+/*                                                           */
+/*            Changed integer type/precision.                */
+/*                                                           */
+/*            Removed genlongalloc/genlongfree functions.    */
+/*                                                           */
+/*            Added get_mem and rtn_mem macros.              */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*            Removed deallocating message parameter from    */
+/*            EnvReleaseMem.                                 */
+/*                                                           */
+/*            Removed support for BLOCK_MEMORY.              */
+/*                                                           */
+/*      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. */
+/*                                                           */
+/*      6.41: Fixed MEM_TABLE_SIZE=0 release-mem crash.      */
+/*                                                           */
+/*************************************************************/
+
+#include <stdio.h>
+
+#include "setup.h"
+
+#include "constant.h"
+#include "envrnmnt.h"
+#include "memalloc.h"
+#include "prntutil.h"
+#include "router.h"
+#include "utility.h"
+
+#include <stdlib.h>
+
+#if WIN_MVC
+#include <malloc.h>
+#endif
+
+#define STRICT_ALIGN_SIZE sizeof(double)
+
+#define SpecialMalloc(sz) malloc((STD_SIZE) sz)
+#define SpecialFree(ptr) free(ptr)
+
+/********************************************/
+/* InitializeMemory: Sets up memory tables. */
+/********************************************/
+void InitializeMemory(
+  Environment *theEnv)
+  {
+   AllocateEnvironmentData(theEnv,MEMORY_DATA,sizeof(struct memoryData),NULL);
+
+   MemoryData(theEnv)->OutOfMemoryCallback = DefaultOutOfMemoryFunction;
+
+#if (MEM_TABLE_SIZE > 0)
+   MemoryData(theEnv)->MemoryTable = (struct memoryPtr **)
+                 malloc((STD_SIZE) (sizeof(struct memoryPtr *) * MEM_TABLE_SIZE));
+
+   if (MemoryData(theEnv)->MemoryTable == NULL)
+     {
+      PrintErrorID(theEnv,"MEMORY",1,true);
+      WriteString(theEnv,STDERR,"Out of memory.\n");
+      ExitRouter(theEnv,EXIT_FAILURE);
+     }
+   else
+     {
+      int i;
+
+      for (i = 0; i < MEM_TABLE_SIZE; i++) MemoryData(theEnv)->MemoryTable[i] = NULL;
+     }
+#else // MEM_TABLE_SIZE == 0
+      MemoryData(theEnv)->MemoryTable = NULL;
+#endif
+  }
+
+/***************************************************/
+/* genalloc: A generic memory allocation function. */
+/***************************************************/
+void *genalloc(
+  Environment *theEnv,
+  size_t size)
+  {
+   void *memPtr;
+
+   memPtr = malloc(size);
+
+   if (memPtr == NULL)
+     {
+      ReleaseMem(theEnv,(long long) ((size * 5 > 4096) ? size * 5 : 4096));
+      memPtr = malloc(size);
+      if (memPtr == NULL)
+        {
+         ReleaseMem(theEnv,-1);
+         memPtr = malloc(size);
+         while (memPtr == NULL)
+           {
+            if ((*MemoryData(theEnv)->OutOfMemoryCallback)(theEnv,size))
+              return NULL;
+            memPtr = malloc(size);
+           }
+        }
+     }
+
+   MemoryData(theEnv)->MemoryAmount += size;
+   MemoryData(theEnv)->MemoryCalls++;
+
+   return memPtr;
+  }
+
+/***********************************************/
+/* DefaultOutOfMemoryFunction: Function called */
+/*   when the KB runs out of memory.           */
+/***********************************************/
+bool DefaultOutOfMemoryFunction(
+  Environment *theEnv,
+  size_t size)
+  {
+#if MAC_XCD
+#pragma unused(size)
+#endif
+
+   PrintErrorID(theEnv,"MEMORY",1,true);
+   WriteString(theEnv,STDERR,"Out of memory.\n");
+   ExitRouter(theEnv,EXIT_FAILURE);
+   return true;
+  }
+
+/**********************************************************/
+/* SetOutOfMemoryFunction: Allows the function which is   */
+/*   called when the KB runs out of memory to be changed. */
+/**********************************************************/
+OutOfMemoryFunction *SetOutOfMemoryFunction(
+  Environment *theEnv,
+  OutOfMemoryFunction *functionPtr)
+  {
+   OutOfMemoryFunction *tmpPtr;
+
+   tmpPtr = MemoryData(theEnv)->OutOfMemoryCallback;
+   MemoryData(theEnv)->OutOfMemoryCallback = functionPtr;
+   return tmpPtr;
+  }
+
+/****************************************************/
+/* genfree: A generic memory deallocation function. */
+/****************************************************/
+void genfree(
+  Environment *theEnv,
+  void *waste,
+  size_t size)
+  {
+   free(waste);
+
+   MemoryData(theEnv)->MemoryAmount -= size;
+   MemoryData(theEnv)->MemoryCalls--;
+  }
+
+/******************************************************/
+/* genrealloc: Simple (i.e. dumb) version of realloc. */
+/******************************************************/
+void *genrealloc(
+  Environment *theEnv,
+  void *oldaddr,
+  size_t oldsz,
+  size_t newsz)
+  {
+   char *newaddr;
+   unsigned i;
+   size_t limit;
+
+   newaddr = ((newsz != 0) ? (char *) gm2(theEnv,newsz) : NULL);
+
+   if (oldaddr != NULL)
+     {
+      limit = (oldsz < newsz) ? oldsz : newsz;
+      for (i = 0 ; i < limit ; i++)
+        { newaddr[i] = ((char *) oldaddr)[i]; }
+      for ( ; i < newsz; i++)
+        { newaddr[i] = '\0'; }
+      rm(theEnv,oldaddr,oldsz);
+     }
+
+   return((void *) newaddr);
+  }
+
+/********************************/
+/* MemUsed: C access routine */
+/*   for the mem-used command.  */
+/********************************/
+long long MemUsed(
+  Environment *theEnv)
+  {
+   return MemoryData(theEnv)->MemoryAmount;
+  }
+
+/***********************************/
+/* MemRequests: C access routine   */
+/*   for the mem-requests command. */
+/***********************************/
+long long MemRequests(
+  Environment *theEnv)
+  {
+   return MemoryData(theEnv)->MemoryCalls;
+  }
+
+/***************************************/
+/* UpdateMemoryUsed: Allows the amount */
+/*   of memory used to be updated.     */
+/***************************************/
+long long UpdateMemoryUsed(
+  Environment *theEnv,
+  long long value)
+  {
+   MemoryData(theEnv)->MemoryAmount += value;
+   return MemoryData(theEnv)->MemoryAmount;
+  }
+
+/*******************************************/
+/* UpdateMemoryRequests: Allows the number */
+/*   of memory requests to be updated.     */
+/*******************************************/
+long long UpdateMemoryRequests(
+  Environment *theEnv,
+  long long value)
+  {
+   MemoryData(theEnv)->MemoryCalls += value;
+   return MemoryData(theEnv)->MemoryCalls;
+  }
+
+/**********************************/
+/* ReleaseMem: C access routine   */
+/*   for the release-mem command. */
+/**********************************/
+long long ReleaseMem(
+  Environment *theEnv,
+  long long maximum)
+  {
+   long long amount = 0;
+#if (MEM_TABLE_SIZE > 0)
+   struct memoryPtr *tmpPtr, *memPtr;
+   unsigned int i;
+   long long returns = 0;
+   
+   for (i = (MEM_TABLE_SIZE - 1) ; i >= sizeof(char *) ; i--)
+     {
+      YieldTime(theEnv);
+      memPtr = MemoryData(theEnv)->MemoryTable[i];
+      while (memPtr != NULL)
+        {
+         tmpPtr = memPtr->next;
+         genfree(theEnv,memPtr,i);
+         memPtr = tmpPtr;
+         amount += i;
+         returns++;
+         if ((returns % 100) == 0)
+           { YieldTime(theEnv); }
+        }
+      MemoryData(theEnv)->MemoryTable[i] = NULL;
+      if ((amount > maximum) && (maximum > 0))
+        { return amount; }
+     }
+#endif
+
+   return amount;
+  }
+
+/*****************************************************/
+/* gm1: Allocates memory and sets all bytes to zero. */
+/*****************************************************/
+void *gm1(
+  Environment *theEnv,
+  size_t size)
+  {
+   struct memoryPtr *memPtr;
+   char *tmpPtr;
+   size_t i;
+
+   if ((size < sizeof(char *)) ||
+       (size >= MEM_TABLE_SIZE))
+     {
+      tmpPtr = (char *) genalloc(theEnv,size);
+      for (i = 0 ; i < size ; i++)
+        { tmpPtr[i] = '\0'; }
+      return((void *) tmpPtr);
+     }
+
+   memPtr = (struct memoryPtr *) MemoryData(theEnv)->MemoryTable[size];
+   if (memPtr == NULL)
+     {
+      tmpPtr = (char *) genalloc(theEnv,size);
+      for (i = 0 ; i < size ; i++)
+        { tmpPtr[i] = '\0'; }
+      return((void *) tmpPtr);
+     }
+
+   MemoryData(theEnv)->MemoryTable[size] = memPtr->next;
+
+   tmpPtr = (char *) memPtr;
+   for (i = 0 ; i < size ; i++)
+     { tmpPtr[i] = '\0'; }
+
+   return ((void *) tmpPtr);
+  }
+
+/*****************************************************/
+/* gm2: Allocates memory and does not initialize it. */
+/*****************************************************/
+void *gm2(
+  Environment *theEnv,
+  size_t size)
+  {
+#if (MEM_TABLE_SIZE > 0)
+   struct memoryPtr *memPtr;
+#endif
+
+   if (size < sizeof(char *))
+     { return genalloc(theEnv,size); }
+
+#if (MEM_TABLE_SIZE > 0)
+   if (size >= MEM_TABLE_SIZE) return genalloc(theEnv,size);
+
+   memPtr = (struct memoryPtr *) MemoryData(theEnv)->MemoryTable[size];
+   if (memPtr == NULL)
+     { return genalloc(theEnv,size); }
+
+   MemoryData(theEnv)->MemoryTable[size] = memPtr->next;
+
+   return ((void *) memPtr);
+#else
+   return genalloc(theEnv,size);
+#endif
+  }
+
+/****************************************/
+/* rm: Returns a block of memory to the */
+/*   maintained pool of free memory.    */
+/****************************************/
+void rm(
+  Environment *theEnv,
+  void *str,
+  size_t size)
+  {
+#if (MEM_TABLE_SIZE > 0)
+   struct memoryPtr *memPtr;
+#endif
+
+   if (size == 0)
+     {
+      SystemError(theEnv,"MEMORY",1);
+      ExitRouter(theEnv,EXIT_FAILURE);
+      return;
+     }
+
+   if (size < sizeof(char *)) 
+     {
+      genfree(theEnv,str,size);
+      return;
+     }
+
+#if (MEM_TABLE_SIZE > 0)
+   if (size >= MEM_TABLE_SIZE)
+     {
+      genfree(theEnv,str,size);
+      return;
+     }
+
+   memPtr = (struct memoryPtr *) str;
+   memPtr->next = MemoryData(theEnv)->MemoryTable[size];
+   MemoryData(theEnv)->MemoryTable[size] = memPtr;
+#else
+   genfree(theEnv,str,size);
+#endif
+  }
+
+/***************************************************/
+/* PoolSize: Returns number of bytes in free pool. */
+/***************************************************/
+unsigned long PoolSize(
+  Environment *theEnv)
+  {
+   unsigned long cnt = 0;
+
+#if (MEM_TABLE_SIZE > 0)
+   int i;
+   struct memoryPtr *memPtr;
+
+   for (i = sizeof(char *) ; i < MEM_TABLE_SIZE ; i++)
+     {
+      memPtr = MemoryData(theEnv)->MemoryTable[i];
+      while (memPtr != NULL)
+        {
+         cnt += (unsigned long) i;
+         memPtr = memPtr->next;
+        }
+     }
+#endif
+
+   return(cnt);
+  }
+
+/***************************************************************/
+/* ActualPoolSize : Returns number of bytes DOS requires to    */
+/*   store the free pool.  This routine is functionally        */
+/*   equivalent to pool_size on anything other than the IBM-PC */
+/***************************************************************/
+unsigned long ActualPoolSize(
+  Environment *theEnv)
+  {
+   return(PoolSize(theEnv));
+  }
+
+/*****************************************/
+/* SetConserveMemory: Allows the setting */
+/*    of the memory conservation flag.   */
+/*****************************************/
+bool SetConserveMemory(
+  Environment *theEnv,
+  bool value)
+  {
+   bool ov;
+
+   ov = MemoryData(theEnv)->ConserveMemory;
+   MemoryData(theEnv)->ConserveMemory = value;
+   return ov;
+  }
+
+/****************************************/
+/* GetConserveMemory: Returns the value */
+/*    of the memory conservation flag.  */
+/****************************************/
+bool GetConserveMemory(
+  Environment *theEnv)
+  {
+   return MemoryData(theEnv)->ConserveMemory;
+  }
+
+/**************************/
+/* genmemcpy:             */
+/**************************/
+void genmemcpy(
+  char *dst,
+  char *src,
+  unsigned long size)
+  {
+   unsigned long i;
+
+   for (i = 0L ; i < size ; i++)
+     dst[i] = src[i];
+  }

data/ext/clipsruby/memalloc.h

@@ -0,0 +1,197 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*             CLIPS Version 6.40  10/11/17            */
+   /*                                                     */
+   /*            MEMORY ALLOCATION HEADER FILE            */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Memory allocation routines.                      */
+/*                                                           */
+/* Principal Programmer(s):                                  */
+/*      Gary D. Riley                                        */
+/*                                                           */
+/* Contributing Programmer(s):                               */
+/*                                                           */
+/* Revision History:                                         */
+/*                                                           */
+/*      6.24: Removed HaltExecution check from the           */
+/*            EnvReleaseMem function. DR0863                 */
+/*                                                           */
+/*            Renamed BOOLEAN macro type to intBool.         */
+/*                                                           */
+/*            Corrected code to remove compiler warnings.    */
+/*                                                           */
+/*      6.30: Removed conditional code for unsupported       */
+/*            compilers/operating systems.                   */
+/*                                                           */
+/*            Changed integer type/precision.                */
+/*                                                           */
+/*            Removed genlongalloc/genlongfree functions.    */
+/*                                                           */
+/*            Added get_mem and rtn_mem macros.              */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*            Removed deallocating message parameter from    */
+/*            EnvReleaseMem.                                 */
+/*                                                           */
+/*            Removed support for BLOCK_MEMORY.              */
+/*                                                           */
+/*      6.31: Fix for get_mem macro.                         */
+/*                                                           */
+/*      6.40: Removed LOCALE definition.                     */
+/*                                                           */
+/*            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. */
+/*                                                           */
+/*************************************************************/
+
+#ifndef _H_memalloc
+
+#pragma once
+
+#define _H_memalloc
+
+#include <string.h>
+
+struct memoryPtr;
+
+typedef bool OutOfMemoryFunction(Environment *,size_t);
+
+#ifndef MEM_TABLE_SIZE
+#define MEM_TABLE_SIZE 500
+#endif
+
+struct memoryPtr
+  {
+   struct memoryPtr *next;
+  };
+
+#if (MEM_TABLE_SIZE > 0)
+/*
+ * Normal memory management case
+ */
+
+#define get_struct(theEnv,type) \
+  ((MemoryData(theEnv)->MemoryTable[sizeof(struct type)] == NULL) ? \
+   ((struct type *) genalloc(theEnv,sizeof(struct type))) :\
+   ((MemoryData(theEnv)->TempMemoryPtr = MemoryData(theEnv)->MemoryTable[sizeof(struct type)]),\
+    MemoryData(theEnv)->MemoryTable[sizeof(struct type)] = MemoryData(theEnv)->TempMemoryPtr->next,\
+    ((struct type *) MemoryData(theEnv)->TempMemoryPtr)))
+
+#define rtn_struct(theEnv,type,struct_ptr) \
+  (MemoryData(theEnv)->TempMemoryPtr = (struct memoryPtr *) struct_ptr,\
+   MemoryData(theEnv)->TempMemoryPtr->next = MemoryData(theEnv)->MemoryTable[sizeof(struct type)], \
+   MemoryData(theEnv)->MemoryTable[sizeof(struct type)] = MemoryData(theEnv)->TempMemoryPtr)
+
+#define rtn_sized_struct(theEnv,size,struct_ptr) \
+  (MemoryData(theEnv)->TempMemoryPtr = (struct memoryPtr *) struct_ptr,\
+   MemoryData(theEnv)->TempMemoryPtr->next = MemoryData(theEnv)->MemoryTable[size], \
+   MemoryData(theEnv)->MemoryTable[size] = MemoryData(theEnv)->TempMemoryPtr)
+
+#define get_var_struct(theEnv,type,vsize) \
+  ((((sizeof(struct type) + vsize) <  MEM_TABLE_SIZE) ? \
+    (MemoryData(theEnv)->MemoryTable[sizeof(struct type) + vsize] == NULL) : 1) ? \
+   ((struct type *) genalloc(theEnv,(sizeof(struct type) + vsize))) :\
+   ((MemoryData(theEnv)->TempMemoryPtr = MemoryData(theEnv)->MemoryTable[sizeof(struct type) + vsize]),\
+    MemoryData(theEnv)->MemoryTable[sizeof(struct type) + vsize] = MemoryData(theEnv)->TempMemoryPtr->next,\
+    ((struct type *) MemoryData(theEnv)->TempMemoryPtr)))
+
+#define rtn_var_struct(theEnv,type,vsize,struct_ptr) \
+  (MemoryData(theEnv)->TempSize = sizeof(struct type) + vsize, \
+   ((MemoryData(theEnv)->TempSize < MEM_TABLE_SIZE) ? \
+    (MemoryData(theEnv)->TempMemoryPtr = (struct memoryPtr *) struct_ptr,\
+     MemoryData(theEnv)->TempMemoryPtr->next = MemoryData(theEnv)->MemoryTable[MemoryData(theEnv)->TempSize], \
+     MemoryData(theEnv)->MemoryTable[MemoryData(theEnv)->TempSize] =  MemoryData(theEnv)->TempMemoryPtr) : \
+    (genfree(theEnv,struct_ptr,MemoryData(theEnv)->TempSize),(struct memoryPtr *) struct_ptr)))
+
+#define get_mem(theEnv,size) \
+  (((size <  MEM_TABLE_SIZE) ? \
+    (MemoryData(theEnv)->MemoryTable[size] == NULL) : 1) ? \
+   ((void *) genalloc(theEnv,(size_t) (size))) :\
+   ((MemoryData(theEnv)->TempMemoryPtr = MemoryData(theEnv)->MemoryTable[size]),\
+    MemoryData(theEnv)->MemoryTable[size] = MemoryData(theEnv)->TempMemoryPtr->next,\
+    ((void *) MemoryData(theEnv)->TempMemoryPtr)))
+
+#define rtn_mem(theEnv,size,ptr) \
+  (MemoryData(theEnv)->TempSize = size, \
+   ((MemoryData(theEnv)->TempSize < MEM_TABLE_SIZE) ? \
+    (MemoryData(theEnv)->TempMemoryPtr = (struct memoryPtr *) ptr,\
+     MemoryData(theEnv)->TempMemoryPtr->next = MemoryData(theEnv)->MemoryTable[MemoryData(theEnv)->TempSize], \
+     MemoryData(theEnv)->MemoryTable[MemoryData(theEnv)->TempSize] =  MemoryData(theEnv)->TempMemoryPtr) : \
+    (genfree(theEnv,ptr,MemoryData(theEnv)->TempSize),(struct memoryPtr *) ptr)))
+
+#else // MEM_TABLE_SIZE == 0
+/*
+ * Debug case (routes all memory management through genalloc/genfree to take advantage of
+ * platform, memory debugging aids)
+ */
+#define get_struct(theEnv,type) ((struct type *) genalloc(theEnv,sizeof(struct type)))
+
+#define rtn_struct(theEnv,type,struct_ptr) (genfree(theEnv,struct_ptr,sizeof(struct type)))
+
+#define rtn_sized_struct(theEnv,size,struct_ptr) (genfree(theEnv,struct_ptr,size))
+
+#define get_var_struct(theEnv,type,vsize) ((struct type *) genalloc(theEnv,(sizeof(struct type) + vsize)))
+
+#define rtn_var_struct(theEnv,type,vsize,struct_ptr) (genfree(theEnv,struct_ptr,sizeof(struct type)+vsize))
+
+#define get_mem(theEnv,size) ((struct type *) genalloc(theEnv,(size_t) (size)))
+
+#define rtn_mem(theEnv,size,ptr) (genfree(theEnv,ptr,size))
+
+#endif
+
+#define GenCopyMemory(type,cnt,dst,src) \
+   memcpy((void *) (dst),(void *) (src),sizeof(type) * (size_t) (cnt))
+
+#define MEMORY_DATA 59
+
+struct memoryData
+  {
+   long long MemoryAmount;
+   long long MemoryCalls;
+   bool ConserveMemory;
+   OutOfMemoryFunction *OutOfMemoryCallback;
+   struct memoryPtr *TempMemoryPtr;
+   struct memoryPtr **MemoryTable;
+   size_t TempSize;
+  };
+
+#define MemoryData(theEnv) ((struct memoryData *) GetEnvironmentData(theEnv,MEMORY_DATA))
+
+   void                           InitializeMemory(Environment *);
+   void                          *genalloc(Environment *,size_t);
+   bool                           DefaultOutOfMemoryFunction(Environment *,size_t);
+   OutOfMemoryFunction           *SetOutOfMemoryFunction(Environment *,OutOfMemoryFunction *);
+   void                           genfree(Environment *,void *,size_t);
+   void                          *genrealloc(Environment *,void *,size_t,size_t);
+   long long                      MemUsed(Environment *);
+   long long                      MemRequests(Environment *);
+   long long                      UpdateMemoryUsed(Environment *,long long);
+   long long                      UpdateMemoryRequests(Environment *,long long);
+   long long                      ReleaseMem(Environment *,long long);
+   void                          *gm1(Environment *,size_t);
+   void                          *gm2(Environment *,size_t);
+   void                           rm(Environment *,void *,size_t);
+   unsigned long                  PoolSize(Environment *);
+   unsigned long                  ActualPoolSize(Environment *);
+   bool                           SetConserveMemory(Environment *,bool);
+   bool                           GetConserveMemory(Environment *);
+   void                           genmemcpy(char *,char *,unsigned long);
+
+#endif /* _H_memalloc */
+
+
+
+
+
+