src/clipsrules/core/dffnxcmp.c Source File

00001    /*******************************************************/
00002    /*      "C" Language Integrated Production System      */
00003    /*                                                     */
00004    /*             CLIPS Version 6.20  01/31/02            */
00005    /*                                                     */
00006    /*                                                     */
00007    /*******************************************************/
00008 
00009 /*************************************************************/
00010 /* Purpose: Generic Function Construct Compiler Code         */
00011 /*                                                           */
00012 /* Principal Programmer(s):                                  */
00013 /*      Brian L. Dantes                                      */
00014 /*                                                           */
00015 /* Contributing Programmer(s):                               */
00016 /*                                                           */
00017 /* Revision History:                                         */
00018 /*                                                           */
00019 /*************************************************************/
00020 
00021 /* =========================================
00022    *****************************************
00023                EXTERNAL DEFINITIONS
00024    =========================================
00025    ***************************************** */
00026 #include "setup.h"
00027 
00028 #if DEFFUNCTION_CONSTRUCT && CONSTRUCT_COMPILER && (! RUN_TIME)
00029 
00030 #include "conscomp.h"
00031 #include "envrnmnt.h"
00032 
00033 #define _DFFNXCMP_SOURCE_
00034 #include "dffnxcmp.h"
00035 
00036 /* =========================================
00037    *****************************************
00038       INTERNALLY VISIBLE FUNCTION HEADERS
00039    =========================================
00040    ***************************************** */
00041 
00042 static void ReadyDeffunctionsForCode(void *);
00043 static int DeffunctionsToCode(void *,char *,char *,char *,int,FILE *,int,int);
00044 static void CloseDeffunctionFiles(void *,FILE *,FILE *,int);
00045 static void DeffunctionModuleToCode(void *,FILE *,struct defmodule *,int,int);
00046 static void SingleDeffunctionToCode(void *,FILE *,DEFFUNCTION *,int,int,int);
00047 
00048 /* =========================================
00049    *****************************************
00050           EXTERNALLY VISIBLE FUNCTIONS
00051    =========================================
00052    ***************************************** */
00053 
00054 /***************************************************
00055   NAME         : SetupDeffunctionCompiler
00056   DESCRIPTION  : Initializes the construct compiler
00057                    item for deffunctions
00058   INPUTS       : None
00059   RETURNS      : Nothing useful
00060   SIDE EFFECTS : Code generator item initialized
00061   NOTES        : None
00062  ***************************************************/
00063 globle void SetupDeffunctionCompiler(
00064   void *theEnv)
00065   {
00066    DeffunctionData(theEnv)->DeffunctionCodeItem = AddCodeGeneratorItem(theEnv,"deffunctions",0,ReadyDeffunctionsForCode,
00067                                               NULL,DeffunctionsToCode,2);
00068   }
00069 
00070 
00071 /***************************************************
00072   NAME         : PrintDeffunctionReference
00073   DESCRIPTION  : Prints a reference to the run-time
00074                  deffunction array for the construct
00075                  compiler
00076   INPUTS       : 1) The file output destination
00077                  2) A pointer to the deffunction
00078                  3) The id of the run-time image
00079                  4) The maximum number of indices
00080                     in any array
00081   RETURNS      : Nothing useful
00082   SIDE EFFECTS : Reference printed
00083   NOTES        : None
00084  ***************************************************/
00085 globle void PrintDeffunctionReference(
00086   void *theEnv,
00087   FILE *fp,
00088   DEFFUNCTION *dfPtr,
00089   int imageID,
00090   int maxIndices)
00091   {
00092    if (dfPtr == NULL)
00093      fprintf(fp,"NULL");
00094    else
00095      fprintf(fp,"&%s%d_%d[%d]",ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),imageID,
00096                                (int) ((dfPtr->header.bsaveID / maxIndices) + 1),
00097                                (int) (dfPtr->header.bsaveID % maxIndices));
00098   }
00099 
00100 /****************************************************
00101   NAME         : DeffunctionCModuleReference
00102   DESCRIPTION  : Prints out a reference to a
00103                  deffunction module
00104   INPUTS       : 1) The output file
00105                  2) The id of the module item
00106                  3) The id of the image
00107                  4) The maximum number of elements
00108                     allowed in an array
00109   RETURNS      : Nothing useful
00110   SIDE EFFECTS : Deffunction module reference printed
00111   NOTES        : None
00112  ****************************************************/
00113 globle void DeffunctionCModuleReference(
00114   void *theEnv,
00115   FILE *theFile,
00116   int count,
00117   int imageID,
00118   int maxIndices)
00119   {
00120    fprintf(theFile,"MIHS &%s%d_%d[%d]",
00121                       ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
00122                       imageID,
00123                       (count / maxIndices) + 1,
00124                       (count % maxIndices));
00125   }
00126 
00127 /* =========================================
00128    *****************************************
00129           INTERNALLY VISIBLE FUNCTIONS
00130    =========================================
00131    ***************************************** */
00132 
00133 /***************************************************
00134   NAME         : ReadyDeffunctionsForCode
00135   DESCRIPTION  : Sets index of deffunctions
00136                    for use in compiled expressions
00137   INPUTS       : None
00138   RETURNS      : Nothing useful
00139   SIDE EFFECTS : BsaveIndices set
00140   NOTES        : None
00141  ***************************************************/
00142 static void ReadyDeffunctionsForCode(
00143   void *theEnv)
00144   {
00145    MarkConstructBsaveIDs(theEnv,DeffunctionData(theEnv)->DeffunctionModuleIndex);
00146   }
00147 
00148 /*******************************************************
00149   NAME         : DeffunctionsToCode
00150   DESCRIPTION  : Writes out static array code for
00151                    deffunctions
00152   INPUTS       : 1) The base name of the construct set
00153                  2) The base id for this construct
00154                  3) The file pointer for the header file
00155                  4) The base id for the construct set
00156                  5) The max number of indices allowed
00157                     in an array
00158   RETURNS      : -1 if no deffunctions, 0 on errors,
00159                   1 if deffunctions written
00160   SIDE EFFECTS : Code written to files
00161   NOTES        : None
00162  *******************************************************/
00163 static int DeffunctionsToCode(
00164   void *theEnv,
00165   char *fileName,
00166   char *pathName,
00167   char *fileNameBuffer,
00168   int fileID,
00169   FILE *headerFP,
00170   int imageID,
00171   int maxIndices)
00172   {
00173    int fileCount = 1;
00174    struct defmodule *theModule;
00175    DEFFUNCTION *theDeffunction;
00176    int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
00177    int deffunctionArrayCount = 0, deffunctionArrayVersion = 1;
00178    FILE *moduleFile = NULL, *deffunctionFile = NULL;
00179 
00180    /* ===============================================
00181       Include the appropriate deffunction header file
00182       =============================================== */
00183    fprintf(headerFP,"#include \"dffnxfun.h\"\n");
00184 
00185    /* =============================================================
00186       Loop through all the modules and all the deffunctions writing
00187       their C code representation to the file as they are traversed
00188       ============================================================= */
00189    theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
00190 
00191    while (theModule != NULL)
00192      {
00193       EnvSetCurrentModule(theEnv,(void *) theModule);
00194 
00195       moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
00196                                     moduleArrayVersion,headerFP,
00197                                     "DEFFUNCTION_MODULE",ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
00198                                     FALSE,NULL);
00199 
00200       if (moduleFile == NULL)
00201         {
00202          CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
00203          return(0);
00204         }
00205 
00206       DeffunctionModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices);
00207       moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
00208                                      maxIndices,NULL,NULL);
00209 
00210       theDeffunction = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,NULL);
00211 
00212       while (theDeffunction != NULL)
00213         {
00214          deffunctionFile = OpenFileIfNeeded(theEnv,deffunctionFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
00215                                             deffunctionArrayVersion,headerFP,
00216                                             "DEFFUNCTION",ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
00217                                             FALSE,NULL);
00218          if (deffunctionFile == NULL)
00219            {
00220             CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
00221             return(0);
00222            }
00223 
00224          SingleDeffunctionToCode(theEnv,deffunctionFile,theDeffunction,imageID,
00225                                  maxIndices,moduleCount);
00226          deffunctionArrayCount++;
00227          deffunctionFile = CloseFileIfNeeded(theEnv,deffunctionFile,&deffunctionArrayCount,
00228                                              &deffunctionArrayVersion,maxIndices,NULL,NULL);
00229 
00230          theDeffunction = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,theDeffunction);
00231         }
00232 
00233       theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule);
00234       moduleCount++;
00235       moduleArrayCount++;
00236      }
00237 
00238    CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
00239 
00240    return(1);
00241   }
00242 
00243 /***************************************************
00244   NAME         : CloseDeffunctionFiles
00245   DESCRIPTION  : Closes construct compiler files
00246                   for deffunction structures
00247   INPUTS       : 1) The deffunction module file
00248                  2) The deffunction structure file
00249                  3) The maximum number of indices
00250                     allowed in an array
00251   RETURNS      : Nothing useful
00252   SIDE EFFECTS : Files closed
00253   NOTES        : None
00254  ***************************************************/
00255 static void CloseDeffunctionFiles(
00256   void *theEnv,
00257   FILE *moduleFile,
00258   FILE *deffunctionFile,
00259   int maxIndices)
00260   {
00261    int count = maxIndices;
00262    int arrayVersion = 0;
00263 
00264    if (deffunctionFile != NULL)
00265      {
00266       count = maxIndices;
00267       CloseFileIfNeeded(theEnv,deffunctionFile,&count,&arrayVersion,maxIndices,NULL,NULL);
00268      }
00269 
00270    if (moduleFile != NULL)
00271      {
00272       count = maxIndices;
00273       CloseFileIfNeeded(theEnv,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
00274      }
00275   }
00276 
00277 /***************************************************
00278   NAME         : DeffunctionModuleToCode
00279   DESCRIPTION  : Writes out the C values for a
00280                  deffunction module item
00281   INPUTS       : 1) The output file
00282                  2) The module for the deffunctions
00283                  3) The compile image id
00284                  4) The maximum number of elements
00285                     in an array
00286   RETURNS      : Nothing useful
00287   SIDE EFFECTS : Deffunction module item written
00288   NOTES        : None
00289  ***************************************************/
00290 static void DeffunctionModuleToCode(
00291   void *theEnv,
00292   FILE *theFile,
00293   struct defmodule *theModule,
00294   int imageID,
00295   int maxIndices)
00296   {
00297    fprintf(theFile,"{");
00298    ConstructModuleToCode(theEnv,theFile,theModule,imageID,maxIndices,
00299                          DeffunctionData(theEnv)->DeffunctionModuleIndex,ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem));
00300    fprintf(theFile,"}");
00301   }
00302 
00303 /***************************************************
00304   NAME         : SingleDeffunctionToCode
00305   DESCRIPTION  : Writes out a single deffunction's
00306                  data to the file
00307   INPUTS       : 1) The output file
00308                  2) The deffunction
00309                  3) The compile image id
00310                  4) The maximum number of
00311                     elements in an array
00312                  5) The module index
00313   RETURNS      : Nothing useful
00314   SIDE EFFECTS : Deffunction data written
00315   NOTES        : None
00316  ***************************************************/
00317 static void SingleDeffunctionToCode(
00318   void *theEnv,
00319   FILE *theFile,
00320   DEFFUNCTION *theDeffunction,
00321   int imageID,
00322   int maxIndices,
00323   int moduleCount)
00324   {
00325    /* ==================
00326       Deffunction Header
00327       ================== */
00328 
00329    fprintf(theFile,"{");
00330    ConstructHeaderToCode(theEnv,theFile,&theDeffunction->header,imageID,maxIndices,moduleCount,
00331                          ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
00332                          ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem));
00333 
00334    /* =========================
00335       Deffunction specific data
00336       ========================= */
00337    fprintf(theFile,",0,0,0,");
00338    ExpressionToCode(theEnv,theFile,theDeffunction->code);
00339    fprintf(theFile,",%d,%d,%d",
00340            theDeffunction->minNumberOfParameters,
00341            theDeffunction->maxNumberOfParameters,
00342            theDeffunction->numberOfLocalVars);
00343 
00344    fprintf(theFile,"}");
00345   }
00346 
00347 #endif
00348 
00349 /***************************************************
00350   NAME         :
00351   DESCRIPTION  :
00352   INPUTS       :
00353   RETURNS      :
00354   SIDE EFFECTS :
00355   NOTES        :
00356  ***************************************************/