symblcmp.c

NASA 开发使用的一个专家系统

   int i, j;
   struct floatHashNode *hashPtr;
   int count;
   int numberOfEntries;
   struct floatHashNode **floatTable;
   int newHeader = CLIPS_TRUE;
   FILE *fp;
   int arrayVersion = 1;

   /*====================================*/
   /* Count the total number of entries. */
   /*====================================*/

   floatTable = GetFloatTable();
   count = numberOfEntries = 0;

   for (i = 0; i < FLOAT_HASH_SIZE; i++)
     {
      for (hashPtr = floatTable[i];
           hashPtr != NULL;
           hashPtr = hashPtr->next)
        { numberOfEntries++; }
     }

   if (numberOfEntries == 0) return(version);

   for (i = 1; i <= (numberOfEntries / MaxIndices) + 1 ; i++)
     { fprintf(HeaderFP,"extern struct floatHashNode F%d_%d[];\n",ImageID,i); }

   /*==================*/
   /* Create the file. */
   /*==================*/

   if ((fp = NewCFile(fileName,1,version,CLIPS_FALSE)) == NULL) return(-1);

   /*===================*/
   /* List the entries. */
   /*===================*/

   j = 0;

   for (i = 0; i < FLOAT_HASH_SIZE; i++)
     {
      for (hashPtr = floatTable[i];
           hashPtr != NULL;
           hashPtr = hashPtr->next)
        {
         if (newHeader)
           {
            fprintf(fp,"struct floatHashNode F%d_%d[] = {\n",ImageID,arrayVersion);
            newHeader = CLIPS_FALSE;
           }

         if (hashPtr->next == NULL)
           { fprintf(fp,"{NULL,"); }
         else
           {
            if ((j + 1) >= MaxIndices)
              { fprintf(fp,"{&F%d_%d[%d],",ImageID,arrayVersion + 1,0); }
            else
              { fprintf(fp,"{&F%d_%d[%d],",ImageID,arrayVersion,j + 1); }
           }

         fprintf(fp,"%ld,0,0,0,%d,",hashPtr->count + 1,i);
         fprintf(fp,"%s",FloatToString(hashPtr->contents));

         count++;
         j++;

         if ((count == numberOfEntries) || (j >= MaxIndices))
           {
            fprintf(fp,"}};\n");
            fclose(fp);
            j = 0;
            version++;
            arrayVersion++;
            if (count < numberOfEntries)
              {
               if ((fp = NewCFile(fileName,1,version,CLIPS_FALSE)) == NULL) return(0);
               newHeader = CLIPS_TRUE;
              }
           }
         else
           { fprintf(fp,"},\n"); }
        }
     }

   return(version);
  }

/******************************************************/
/* IntegerHashNodesToCode: Produces the code for the  */
/*   integer hash table entries for a run-time module */
/*   created using the constructs-to-c function.      */
/******************************************************/
static int IntegerHashNodesToCode(fileName,version)
  char *fileName;
  int version;
  {
   int i, j;
   struct integerHashNode *hashPtr;
   int count;
   int numberOfEntries;
   struct integerHashNode **integerTable;
   int newHeader = CLIPS_TRUE;
   FILE *fp;
   int arrayVersion = 1;

   /*====================================*/
   /* Count the total number of entries. */
   /*====================================*/

   integerTable = GetIntegerTable();
   count = numberOfEntries = 0;

   for (i = 0; i < INTEGER_HASH_SIZE; i++)
     {
      for (hashPtr = integerTable[i];
           hashPtr != NULL;
           hashPtr = hashPtr->next)
        { numberOfEntries++; }
     }

   if (numberOfEntries == 0) return(version);

   for (i = 1; i <= (numberOfEntries / MaxIndices) + 1 ; i++)
     { fprintf(HeaderFP,"extern struct integerHashNode I%d_%d[];\n",ImageID,i); }

   /*==================*/
   /* Create the file. */
   /*==================*/

   if ((fp = NewCFile(fileName,1,version,CLIPS_FALSE)) == NULL) return(-1);

   /*===================*/
   /* List the entries. */
   /*===================*/

   j = 0;

   for (i = 0; i < INTEGER_HASH_SIZE; i++)
     {
      for (hashPtr = integerTable[i];
           hashPtr != NULL;
           hashPtr = hashPtr->next)
        {
         if (newHeader)
           {
            fprintf(fp,"struct integerHashNode I%d_%d[] = {\n",ImageID,arrayVersion);
            newHeader = CLIPS_FALSE;
           }

         if (hashPtr->next == NULL)
           { fprintf(fp,"{NULL,"); }
         else
           {
            if ((j + 1) >= MaxIndices)
              { fprintf(fp,"{&I%d_%d[%d],",ImageID,arrayVersion + 1,0); }
            else
              { fprintf(fp,"{&I%d_%d[%d],",ImageID,arrayVersion,j + 1); }
           }

         fprintf(fp,"%ld,0,0,0,%d,",hashPtr->count + 1,i);
         fprintf(fp,"%ld",hashPtr->contents);

         count++;
         j++;

         if ((count == numberOfEntries) || (j >= MaxIndices))
           {
            fprintf(fp,"}};\n");
            fclose(fp);
            j = 0;
            version++;
            arrayVersion++;
            if (count < numberOfEntries)
              {
               if ((fp = NewCFile(fileName,1,version,CLIPS_FALSE)) == NULL) return(0);
               newHeader = CLIPS_TRUE;
              }
           }
         else
           { fprintf(fp,"},\n"); }
        }
     }

   return(version);
  }
  
/****************************************************************/
/* HashTablesToCode: Produces the code for the symbol, integer, */
/*   float, and bitmap hash tables for a run-time module        */
/*   created using the constructs-to-c function.                */
/****************************************************************/
static int HashTablesToCode(fileName)
  char *fileName;
  {
   int i;
   FILE *fp;
   struct symbolHashNode **symbolTable;
   struct floatHashNode **floatTable;
   struct integerHashNode **integerTable;
   struct bitMapHashNode **bitMapTable;

   /*======================================*/
   /* Write the code for the symbol table. */
   /*======================================*/

   symbolTable = GetSymbolTable();

   if ((fp = NewCFile(fileName,1,1,CLIPS_FALSE)) == NULL) return(0);

   fprintf(HeaderFP,"extern struct symbolHashNode *sht%d[];\n",ImageID);
   fprintf(fp,"struct symbolHashNode *sht%d[%d] = {\n",ImageID,SYMBOL_HASH_SIZE);

   for (i = 0; i < SYMBOL_HASH_SIZE; i++)
      {
       PrintSymbolReference(fp,symbolTable[i]);

       if (i + 1 != SYMBOL_HASH_SIZE) fprintf(fp,",\n");
      }

    fprintf(fp,"};\n");

    fclose(fp);

   /*=====================================*/
   /* Write the code for the float table. */
   /*=====================================*/

   floatTable = GetFloatTable();

   if ((fp = NewCFile(fileName,1,2,CLIPS_FALSE)) == NULL) return(0);

   fprintf(HeaderFP,"extern struct floatHashNode *fht%d[];\n",ImageID);
   fprintf(fp,"struct floatHashNode *fht%d[%d] = {\n",ImageID,FLOAT_HASH_SIZE);

   for (i = 0; i < FLOAT_HASH_SIZE; i++)
      {
       if (floatTable[i] == NULL) { fprintf(fp,"NULL"); }
       else PrintFloatReference(fp,floatTable[i]);

       if (i + 1 != FLOAT_HASH_SIZE) fprintf(fp,",\n");
      }

    fprintf(fp,"};\n");

    fclose(fp);

   /*=======================================*/
   /* Write the code for the integer table. */
   /*=======================================*/

   integerTable = GetIntegerTable();

   if ((fp = NewCFile(fileName,1,3,CLIPS_FALSE)) == NULL) return(0);

   fprintf(HeaderFP,"extern struct integerHashNode *iht%d[];\n",ImageID);
   fprintf(fp,"struct integerHashNode *iht%d[%d] = {\n",ImageID,INTEGER_HASH_SIZE);

   for (i = 0; i < INTEGER_HASH_SIZE; i++)
      {
       if (integerTable[i] == NULL) { fprintf(fp,"NULL"); }
       else PrintIntegerReference(fp,integerTable[i]);

       if (i + 1 != INTEGER_HASH_SIZE) fprintf(fp,",\n");
      }

    fprintf(fp,"};\n");

    fclose(fp);

   /*======================================*/
   /* Write the code for the bitmap table. */
   /*======================================*/

   bitMapTable = GetBitMapTable();

   if ((fp = NewCFile(fileName,1,4,CLIPS_FALSE)) == NULL) return(0);

   fprintf(HeaderFP,"extern struct bitMapHashNode *bmht%d[];\n",ImageID);
   fprintf(fp,"struct bitMapHashNode *bmht%d[%d] = {\n",ImageID,BITMAP_HASH_SIZE);

   for (i = 0; i < BITMAP_HASH_SIZE; i++)
      {
       PrintBitMapReference(fp,bitMapTable[i]);

       if (i + 1 != BITMAP_HASH_SIZE) fprintf(fp,",\n");
      }

    fprintf(fp,"};\n");

    fclose(fp);

    return(1);
   }
   
/*****************************************************/
/* PrintSymbolReference: Prints the C code reference */
/*   address to the specified symbol (also used for  */
/*   strings and instance names).                    */
/*****************************************************/
globle VOID PrintSymbolReference(theFile,theSymbol)
  FILE *theFile;
  struct symbolHashNode *theSymbol;
  {
   if (theSymbol == NULL) fprintf(theFile,"NULL");
   else fprintf(theFile,"&S%d_%d[%d]",
                        ImageID,
                        (int) (theSymbol->bucket / MaxIndices) + 1,
                        (int) theSymbol->bucket % MaxIndices);
  }

/****************************************************/
/* PrintFloatReference: Prints the C code reference */
/*   address to the specified float.                */
/****************************************************/
globle VOID PrintFloatReference(theFile,theFloat)
  FILE *theFile;
  struct floatHashNode *theFloat;
  {
   fprintf(theFile,"&F%d_%d[%d]",
                   ImageID,
                   (int) (theFloat->bucket / MaxIndices) + 1,
                   (int) theFloat->bucket % MaxIndices);
  }

/******************************************************/
/* PrintIntegerReference: Prints the C code reference */
/*   address to the specified integer.                */
/******************************************************/
globle VOID PrintIntegerReference(theFile,theInteger)
  FILE *theFile;
  struct integerHashNode *theInteger;
  {
   fprintf(theFile,"&I%d_%d[%d]",
                   ImageID,
                   (int) (theInteger->bucket / MaxIndices) + 1,
                   (int) theInteger->bucket % MaxIndices);
  }
  
/*****************************************************/
/* PrintBitMapReference: Prints the C code reference */
/*   address to the specified bit map.               */
/*****************************************************/
globle VOID PrintBitMapReference(theFile,theBitMap)
  FILE *theFile;
  struct bitMapHashNode *theBitMap;
  {
   if (theBitMap == NULL) fprintf(theFile,"NULL");
   else fprintf(theFile,"&B%d_%d[%d]",
                        ImageID,
                        (int) (theBitMap->bucket / MaxIndices) + 1,
                        (int) theBitMap->bucket % MaxIndices);
  }
    
/*********************************************************/
/* PrintCString: Prints CLIPS strings in the appropriate */
/*   format for C (the " and \ characters are preceeded  */
/*   by a \ and carriage returns are replaced with \n).  */
/*********************************************************/
static VOID PrintCString(theFile,str)
  FILE *theFile;
  char *str;
  {
   int i, slen;

   /*============================================*/
   /* Print the string's opening quotation mark. */
   /*============================================*/
   
   fprintf(theFile,"\"");
   
   /*===============================================*/
   /* Convert and write each character to the file. */
   /*===============================================*/
   
   slen = strlen(str);
   for (i = 0 ; i < slen ; i++)
     {
      /*====================================*/
      /* Preceed " and \ with the \ escape. */
      /*====================================*/
      
      if ((str[i] == '"') || (str[i] == '\\'))
        {
         fputc('\\',theFile);
         fputc(str[i],theFile);
        }
        
      /*====================================*/
      /* Replace a carriage return with \n. */
      /*====================================*/
      
      else if (str[i] == '\n')
        {
         fputc('\\',theFile);
         fputc('n',theFile);
        }
        
      /*===============================*/
      /* All other characters can be   */
      /* printed without modification. */
      /*===============================*/
      
      else
        { fputc(str[i],theFile); }
     }

   /*============================================*/
   /* Print the string's closing quotation mark. */
   /*============================================*/
   
   fprintf(theFile,"\"");
  }

#endif /* CONSTRUCT_COMPILER && (! RUN_TIME) */