clipsruby 0.0.2

data/ext/clipsruby/evaluatn.h

@@ -0,0 +1,211 @@
+   /*******************************************************/
+   /*      "C" Language Integrated Production System      */
+   /*                                                     */
+   /*             CLIPS Version 6.41  11/05/22            */
+   /*                                                     */
+   /*               EVALUATION HEADER FILE                */
+   /*******************************************************/
+
+/*************************************************************/
+/* Purpose: Provides routines for evaluating expressions.    */
+/*                                                           */
+/* 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.         */
+/*                                                           */
+/*            Added EvaluateAndStoreInDataObject function.   */
+/*                                                           */
+/*      6.30: Added support for passing context information  */
+/*            to user defined functions.                     */
+/*                                                           */
+/*            Added support for external address hash table  */
+/*            and subtyping.                                 */
+/*                                                           */
+/*            Changed integer type/precision.                */
+/*                                                           */
+/*            Support for long long integers.                */
+/*                                                           */
+/*            Changed garbage collection algorithm.          */
+/*                                                           */
+/*            Support for DATA_OBJECT_ARRAY primitive.       */
+/*                                                           */
+/*            Added const qualifiers to remove C++           */
+/*            deprecation warnings.                          */
+/*                                                           */
+/*            Converted API macros to function calls.        */
+/*                                                           */
+/*      6.40: Added Env prefix to GetEvaluationError and     */
+/*            SetEvaluationError functions.                  */
+/*                                                           */
+/*            Added Env prefix to GetHaltExecution and       */
+/*            SetHaltExecution functions.                    */
+/*                                                           */
+/*            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. */
+/*                                                           */
+/*            UDF redesign.                                  */
+/*                                                           */
+/*            Removed DATA_OBJECT_ARRAY primitive type.      */
+/*                                                           */
+/*      6.41: Added FCBPopArgument function.                 */
+/*                                                           */
+/*************************************************************/
+
+#ifndef _H_evaluatn
+
+#pragma once
+
+#define _H_evaluatn
+
+#include "constant.h"
+#include "entities.h"
+
+typedef struct functionCallBuilder FunctionCallBuilder;
+
+struct functionCallBuilder
+  {
+   Environment *fcbEnv;
+   CLIPSValue *contents;
+   size_t bufferReset;
+   size_t length;
+   size_t bufferMaximum;
+  };
+
+typedef enum
+  {
+   FCBE_NO_ERROR = 0,
+   FCBE_NULL_POINTER_ERROR,
+   FCBE_FUNCTION_NOT_FOUND_ERROR,
+   FCBE_INVALID_FUNCTION_ERROR,
+   FCBE_ARGUMENT_COUNT_ERROR,
+   FCBE_ARGUMENT_TYPE_ERROR,
+   FCBE_PROCESSING_ERROR
+  } FunctionCallBuilderError;
+
+#define PARAMETERS_UNBOUNDED USHRT_MAX
+
+#define C_POINTER_EXTERNAL_ADDRESS 0
+
+struct externalAddressType
+  {
+   const  char *name;
+   void (*shortPrintFunction)(Environment *,const char *,void *);
+   void (*longPrintFunction)(Environment *,const char *,void *);
+   bool (*discardFunction)(Environment *,void *);
+   void (*newFunction)(UDFContext *,UDFValue *);
+   bool (*callFunction)(UDFContext *,UDFValue *,UDFValue *);
+  };
+
+#define CoerceToLongInteger(t,v) ((t == INTEGER_TYPE) ? ValueToLong(v) : (long) ValueToDouble(v))
+#define CoerceToInteger(t,v) ((t == INTEGER_TYPE) ? (int) ValueToLong(v) : (int) ValueToDouble(v))
+#define CoerceToDouble(t,v) ((t == INTEGER_TYPE) ? (double) ValueToLong(v) : ValueToDouble(v))
+
+#define GetFirstArgument()           (EvaluationData(theEnv)->CurrentExpression->argList)
+#define GetNextArgument(ep)          (ep->nextArg)
+
+#define MAXIMUM_PRIMITIVES 150
+#define MAXIMUM_EXTERNAL_ADDRESS_TYPES 10
+
+#define BITS_PER_BYTE    8
+
+#define BitwiseTest(n,b)   (((n) & (char) (1 << (b))) ? true : false)
+#define BitwiseSet(n,b)    (n |= (char) (1 << (b)))
+#define BitwiseClear(n,b)  (n &= (char) ~(1 << (b)))
+
+#define CountToBitMapSize(c) (((c) + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE) 
+#define TestBitMap(map,id)  BitwiseTest(map[(id) / BITS_PER_BYTE],(id) % BITS_PER_BYTE)
+#define SetBitMap(map,id)   BitwiseSet(map[(id) / BITS_PER_BYTE],(id) % BITS_PER_BYTE)
+#define ClearBitMap(map,id) BitwiseClear(map[(id) / BITS_PER_BYTE],(id) % BITS_PER_BYTE)
+
+#define EVALUATION_DATA 44
+
+struct evaluationData
+  {
+   struct expr *CurrentExpression;
+   bool EvaluationError;
+   bool HaltExecution;
+   int CurrentEvaluationDepth;
+   int numberOfAddressTypes;
+   struct entityRecord *PrimitivesArray[MAXIMUM_PRIMITIVES];
+   struct externalAddressType *ExternalAddressTypes[MAXIMUM_EXTERNAL_ADDRESS_TYPES];
+  };
+
+#define EvaluationData(theEnv) ((struct evaluationData *) GetEnvironmentData(theEnv,EVALUATION_DATA))
+
+   void                           InitializeEvaluationData(Environment *);
+   bool                           EvaluateExpression(Environment *,struct expr *,UDFValue *);
+   void                           SetEvaluationError(Environment *,bool);
+   bool                           GetEvaluationError(Environment *);
+   void                           SetHaltExecution(Environment *,bool);
+   bool                           GetHaltExecution(Environment *);
+   void                           ReturnValues(Environment *,UDFValue *,bool);
+   void                           WriteUDFValue(Environment *,const char *,UDFValue *);
+   void                           WriteCLIPSValue(Environment *,const char *,CLIPSValue *);
+   void                           SetMultifieldErrorValue(Environment *,UDFValue *);
+   void                           CopyDataObject(Environment *,UDFValue *,UDFValue *,int);
+   void                           AtomInstall(Environment *,unsigned short,void *);
+   void                           AtomDeinstall(Environment *,unsigned short,void *);
+   void                           Retain(Environment *,TypeHeader *);
+   void                           Release(Environment *,TypeHeader *);
+   void                           RetainCV(Environment *,CLIPSValue *);
+   void                           ReleaseCV(Environment *,CLIPSValue *);
+   void                           RetainUDFV(Environment *,UDFValue *);
+   void                           ReleaseUDFV(Environment *,UDFValue *);
+   struct expr                   *ConvertValueToExpression(Environment *,UDFValue *);
+   unsigned long                  GetAtomicHashValue(unsigned short,void *,unsigned short);
+   void                           InstallPrimitive(Environment *,struct entityRecord *,int);
+   int                            InstallExternalAddressType(Environment *,struct externalAddressType *);
+   void                           TransferDataObjectValues(UDFValue *,UDFValue *);
+   struct expr                   *FunctionReferenceExpression(Environment *,const char *);
+   bool                           GetFunctionReference(Environment *,const char *,Expression *);
+   bool                           DOsEqual(UDFValue *,UDFValue *);
+   bool                           EvaluateAndStoreInDataObject(Environment *,bool,Expression *,UDFValue *,bool);
+   void                           ResetErrorFlags(Environment *);
+   FunctionCallBuilder           *CreateFunctionCallBuilder(Environment *,size_t);
+   void                           FCBAppendUDFValue(FunctionCallBuilder *,UDFValue *);
+   void                           FCBAppend(FunctionCallBuilder *,CLIPSValue *);
+   void                           FCBAppendCLIPSInteger(FunctionCallBuilder *,CLIPSInteger *);
+   void                           FCBAppendInteger(FunctionCallBuilder *,long long);
+   void                           FCBAppendCLIPSFloat(FunctionCallBuilder *,CLIPSFloat *);
+   void                           FCBAppendFloat(FunctionCallBuilder *,double);
+   void                           FCBAppendCLIPSLexeme(FunctionCallBuilder *,CLIPSLexeme *);
+   void                           FCBAppendSymbol(FunctionCallBuilder *,const char *);
+   void                           FCBAppendString(FunctionCallBuilder *,const char *);
+   void                           FCBAppendInstanceName(FunctionCallBuilder *,const char *);
+   void                           FCBAppendCLIPSExternalAddress(FunctionCallBuilder *,CLIPSExternalAddress *);
+   void                           FCBAppendFact(FunctionCallBuilder *,Fact *);
+   void                           FCBAppendInstance(FunctionCallBuilder *,Instance *);
+   void                           FCBAppendMultifield(FunctionCallBuilder *,Multifield *);
+   void                           FCBPopArgument(FunctionCallBuilder *);
+   void                           FCBDispose(FunctionCallBuilder *);
+   void                           FCBReset(FunctionCallBuilder *);
+   FunctionCallBuilderError       FCBCall(FunctionCallBuilder *,const char *,CLIPSValue *);
+   
+#define CVIsType(cv,cvType) (((1 << (((TypeHeader *) (cv)->value)->type)) & (cvType)) ? true : false)
+
+#define ValueIsType(value,vType) ((1 << (((TypeHeader *) value)->type)) & (vType))
+
+#define CVCoerceToFloat(cv) (((cv)->header->type == FLOAT_TYPE) ? \
+                             ((cv)->floatValue->contents) : \
+                             ((double) (cv)->integerValue->contents))
+
+#define CVCoerceToInteger(cv) (((cv)->header->type == INTEGER_TYPE) ? \
+                               ((cv)->integerValue->contents) : \
+                               ((long long) (cv)->floatValue->contents))
+
+#endif /* _H_evaluatn */