static void SlotToCode(
void *theEnv,
FILE *theFile,
struct templateSlot *theSlot,
int imageID,
int maxIndices,
int slotCount)
{
/*===========*/
/* Slot Name */
/*===========*/
fprintf(theFile,"{");
PrintSymbolReference(theEnv,theFile,theSlot->slotName);
/*=============================*/
/* Multislot and Default Flags */
/*=============================*/
fprintf(theFile,",%d,%d,%d,%d,",theSlot->multislot,theSlot->noDefault,
theSlot->defaultPresent,theSlot->defaultDynamic);
/*=============*/
/* Constraints */
/*=============*/
PrintConstraintReference(theEnv,theFile,theSlot->constraints,imageID,maxIndices);
/*===============*/
/* Default Value */
/*===============*/
fprintf(theFile,",");
PrintHashedExpressionReference(theEnv,theFile,theSlot->defaultList,imageID,maxIndices);
/*============*/
/* Facet List */
/*============*/
fprintf(theFile,",");
PrintHashedExpressionReference(theEnv,theFile,theSlot->facetList,imageID,maxIndices);
fprintf(theFile,",");
/*===========*/
/* Next Slot */
/*===========*/
if (theSlot->next == NULL)
{ fprintf(theFile,"NULL}"); }
else
{
fprintf(theFile,"&%s%d_%d[%d]}",SlotPrefix(),imageID,
((slotCount+1) / maxIndices) + 1,
(slotCount+1) % maxIndices);
}
}
globle void ConstructHeaderToCode(
FILE *theFile,
struct constructHeader *theConstruct,
int imageID,
int maxIndices,
int moduleCount,
char *constructModulePrefix,
char *constructPrefix)
{
/*================*/
/* Construct Name */
/*================*/
fprintf(theFile,"{");
PrintSymbolReference(theFile,theConstruct->name);
/*===================*/
/* Pretty Print Form */
/*===================*/
fprintf(theFile,",NULL,");
/*====================*/
/* Construct Module */
/*====================*/
fprintf(theFile,"MIHS &%s%d_%d[%d],",
constructModulePrefix,
imageID,
(moduleCount / maxIndices) + 1,
moduleCount % maxIndices);
/*==========*/
/* Bsave ID */
/*==========*/
fprintf(theFile,"0,");
/*================*/
/* Next Construct */
/*================*/
if (theConstruct->next == NULL)
{ fprintf(theFile,"NULL}"); }
else
{
fprintf(theFile,"CHS &%s%d_%ld[%ld]}",
constructPrefix,
imageID,
(theConstruct->next->bsaveID / maxIndices) + 1,
theConstruct->next->bsaveID % maxIndices);
}
}
static int HashTablesToCode(
void *theEnv,
EXEC_STATUS,
char *fileName,
char *pathName,
char *fileNameBuffer)
{
unsigned long i;
FILE *fp;
struct symbolHashNode **symbolTable;
struct floatHashNode **floatTable;
struct integerHashNode **integerTable;
struct bitMapHashNode **bitMapTable;
/*======================================*/
/* Write the code for the symbol table. */
/*======================================*/
symbolTable = GetSymbolTable(theEnv,execStatus);
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,1,FALSE)) == NULL) return(0);
fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct symbolHashNode *sht%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID);
fprintf(fp,"struct symbolHashNode *sht%d[%ld] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,SYMBOL_HASH_SIZE);
for (i = 0; i < SYMBOL_HASH_SIZE; i++)
{
PrintSymbolReference(theEnv,execStatus,fp,symbolTable[i]);
if (i + 1 != SYMBOL_HASH_SIZE) fprintf(fp,",\n");
}
fprintf(fp,"};\n");
GenClose(theEnv,execStatus,fp);
/*=====================================*/
/* Write the code for the float table. */
/*=====================================*/
floatTable = GetFloatTable(theEnv,execStatus);
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,2,FALSE)) == NULL) return(0);
fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct floatHashNode *fht%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID);
fprintf(fp,"struct floatHashNode *fht%d[%d] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,FLOAT_HASH_SIZE);
for (i = 0; i < FLOAT_HASH_SIZE; i++)
{
if (floatTable[i] == NULL) { fprintf(fp,"NULL"); }
else PrintFloatReference(theEnv,execStatus,fp,floatTable[i]);
if (i + 1 != FLOAT_HASH_SIZE) fprintf(fp,",\n");
}
fprintf(fp,"};\n");
GenClose(theEnv,execStatus,fp);
/*=======================================*/
/* Write the code for the integer table. */
/*=======================================*/
integerTable = GetIntegerTable(theEnv,execStatus);
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,3,FALSE)) == NULL) return(0);
fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct integerHashNode *iht%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID);
fprintf(fp,"struct integerHashNode *iht%d[%d] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,INTEGER_HASH_SIZE);
for (i = 0; i < INTEGER_HASH_SIZE; i++)
{
if (integerTable[i] == NULL) { fprintf(fp,"NULL"); }
else PrintIntegerReference(theEnv,execStatus,fp,integerTable[i]);
if (i + 1 != INTEGER_HASH_SIZE) fprintf(fp,",\n");
}
fprintf(fp,"};\n");
GenClose(theEnv,execStatus,fp);
/*======================================*/
/* Write the code for the bitmap table. */
/*======================================*/
bitMapTable = GetBitMapTable(theEnv,execStatus);
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,4,FALSE)) == NULL) return(0);
fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct bitMapHashNode *bmht%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID);
fprintf(fp,"struct bitMapHashNode *bmht%d[%d] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,BITMAP_HASH_SIZE);
for (i = 0; i < BITMAP_HASH_SIZE; i++)
{
PrintBitMapReference(theEnv,execStatus,fp,bitMapTable[i]);
if (i + 1 != BITMAP_HASH_SIZE) fprintf(fp,",\n");
}
fprintf(fp,"};\n");
GenClose(theEnv,execStatus,fp);
return(1);
}
static int PortItemsToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
int *fileCount)
{
struct defmodule *theDefmodule = NULL;
struct portItem *thePortItem = NULL;
int portItemCount = 0;
int importChecked = FALSE;
int exportChecked = FALSE;
FILE *portItemsFile = NULL;
int portItemArrayVersion = 1;
/*=================================================================*/
/* Loop through each of the portItem data structures writing their */
/* C code representation to the file as they are traversed. */
/*=================================================================*/
for (thePortItem = GetNextPortItem(theEnv,&theDefmodule,&thePortItem,&importChecked,&exportChecked);
thePortItem != NULL;
thePortItem = GetNextPortItem(theEnv,&theDefmodule,&thePortItem,&importChecked,&exportChecked))
{
/*===========================================*/
/* Open a new file to write to if necessary. */
/*===========================================*/
portItemsFile = OpenFileIfNeeded(theEnv,portItemsFile,fileName,pathName,fileNameBuffer,fileID,imageID,
fileCount,portItemArrayVersion,headerFP,
"struct portItem",PortPrefix(),
FALSE,NULL);
if (portItemsFile == NULL)
{
portItemCount = maxIndices;
CloseFileIfNeeded(theEnv,portItemsFile,&portItemCount,
&portItemArrayVersion,maxIndices,NULL,NULL);
return(FALSE);
}
/*================================================*/
/* Write the portItem data structure to the file. */
/*================================================*/
fprintf(portItemsFile,"{");
PrintSymbolReference(theEnv,portItemsFile,thePortItem->moduleName);
fprintf(portItemsFile,",");
PrintSymbolReference(theEnv,portItemsFile,thePortItem->constructType);
fprintf(portItemsFile,",");
PrintSymbolReference(theEnv,portItemsFile,thePortItem->constructName);
fprintf(portItemsFile,",");
if (thePortItem->next == NULL)
{ fprintf(portItemsFile,"NULL}"); }
else
{
fprintf(portItemsFile,"&%s%d_%d[%d]}",PortPrefix(),imageID,
((portItemCount+1) / maxIndices) + 1,
(portItemCount+1) % maxIndices);
}
/*==================================================*/
/* Increment the number of portItem data structures */
/* written and close the output file if necessary. */
/*==================================================*/
portItemCount++;
CloseFileIfNeeded(theEnv,portItemsFile,&portItemCount,&portItemArrayVersion,
maxIndices,NULL,NULL);
}
/*===================================================*/
/* Close the output file and return TRUE to indicate */
/* the data structures were successfully written. */
/*===================================================*/
portItemCount = maxIndices;
CloseFileIfNeeded(theEnv,portItemsFile,&portItemCount,
&portItemArrayVersion,maxIndices,NULL,NULL);
return(TRUE);
}
static int ConstructToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
struct defmodule *theConstruct;
FILE *moduleFile = NULL, *itemsFile;
int portItemCount = 0;
struct portItem *portItemPtr;
int mihCount = 0, moduleCount = 0;
int j;
struct moduleItem *theItem;
int moduleArrayVersion = 1;
int fileCount = 2;
/*================================================*/
/* Include the appropriate defmodule header file. */
/*================================================*/
fprintf(headerFP,"#include \"moduldef.h\"\n");
/*============================================*/
/* Open up the items file for the defmodules. */
/* Only one file of this type is created so */
/* the maximum number of indices is ignored. */
/*============================================*/
if ((itemsFile = NewCFile(theEnv,fileName,pathName,fileNameBuffer,fileID,1,FALSE)) == NULL)
{ return(FALSE); }
fprintf(itemsFile,"struct defmoduleItemHeader *%s%d_%d[] = {\n",ItemPrefix(),imageID,1);
fprintf(headerFP,"extern struct defmoduleItemHeader *%s%d_%d[];\n",ItemPrefix(),imageID,1);
/*======================================================*/
/* Loop through all the defmodules writing their C code */
/* representation to the file as they are traversed. */
/*======================================================*/
for (theConstruct = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theConstruct != NULL;
theConstruct = (struct defmodule *) EnvGetNextDefmodule(theEnv,theConstruct))
{
/*===========================================*/
/* Open a new file to write to if necessary. */
/*===========================================*/
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,
&fileCount,moduleArrayVersion,headerFP,
"struct defmodule",DefmodulePrefix(),
FALSE,NULL);
if (moduleFile == NULL)
{
moduleCount = maxIndices;
CloseFileIfNeeded(theEnv,moduleFile,&moduleCount,
&moduleArrayVersion,maxIndices,NULL,NULL);
GenClose(theEnv,itemsFile);
return(FALSE);
}
/*======================================*/
/* Write the construct name and ppform. */
/*======================================*/
fprintf(moduleFile,"{");
PrintSymbolReference(theEnv,moduleFile,theConstruct->name);
fprintf(moduleFile,",NULL,");
/*=====================================================*/
/* Write the items array pointers to other constructs. */
/*=====================================================*/
fprintf(moduleFile,"&%s%d_1[%d],",ItemPrefix(),imageID,mihCount);
for (j = 0, theItem = GetListOfModuleItems(theEnv);
(j < GetNumberOfModuleItems(theEnv)) && (theItem != NULL) ;
j++, theItem = theItem->next)
{
mihCount++;
if (theItem->constructsToCModuleReference == NULL)
{ fprintf(itemsFile,"NULL"); }
else
{ (*theItem->constructsToCModuleReference)(theEnv,itemsFile,(int) theConstruct->bsaveID,imageID,maxIndices); }
if ((j + 1) < GetNumberOfModuleItems(theEnv)) fprintf(itemsFile,",");
else if (theConstruct->next != NULL) fprintf(itemsFile,",\n");
}
/*=================================*/
/* Write the importList reference. */
/*=================================*/
if (theConstruct->importList == NULL)
{ fprintf(moduleFile,"NULL,"); }
else
{
fprintf(moduleFile,"&%s%d_%d[%d],",PortPrefix(),imageID,
(portItemCount / maxIndices) + 1,
portItemCount % maxIndices);
for (portItemPtr = theConstruct->importList;
portItemPtr != NULL;
portItemPtr = portItemPtr->next)
{ portItemCount++; }
}
/*=================================*/
/* Write the exportList reference. */
/*=================================*/
if (theConstruct->exportList == NULL)
{ fprintf(moduleFile,"NULL,"); }
else
{
fprintf(moduleFile,"&%s%d_%d[%d],",PortPrefix(),imageID,
(portItemCount / maxIndices) + 1,
portItemCount % maxIndices);
for (portItemPtr = theConstruct->exportList;
portItemPtr != NULL;
portItemPtr = portItemPtr->next)
{ portItemCount++; }
}
/*=====================*/
/* Write the bsave id. */
/*=====================*/
fprintf(moduleFile,"0,%ld,",theConstruct->bsaveID);
/*======================*/
/* Write the user data. */
/*======================*/
fprintf(moduleFile,"NULL,");
/*===========================*/
/* Write the next reference. */
/*===========================*/
if (theConstruct->next == NULL)
{ fprintf(moduleFile,"NULL}"); }
else
{
fprintf(moduleFile,"&%s%d_%d[%d]}",ConstructPrefix(DefmoduleData(theEnv)->DefmoduleCodeItem),imageID,
(int) (theConstruct->next->bsaveID / maxIndices) + 1,
(int) theConstruct->next->bsaveID % maxIndices);
}
/*===================================================*/
/* Increment the number of defmodule data structures */
/* written and close the output file if necessary. */
/*===================================================*/
moduleCount++;
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
}
/*=========================*/
/* Close the output files. */
/*=========================*/
moduleCount = maxIndices;
CloseFileIfNeeded(theEnv,moduleFile,&moduleCount,
&moduleArrayVersion,maxIndices,NULL,NULL);
fprintf(itemsFile,"};\n");
GenClose(theEnv,itemsFile);
/*=========================================*/
/* Write out the portItem data structures. */
/*=========================================*/
if (portItemCount == 0) return(TRUE);
return(PortItemsToCode(theEnv,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,maxIndices,&fileCount));
}
static void DumpExpression(
struct expr *exprPtr)
{
while (exprPtr != NULL)
{
fprintf(ExpressionFP,"{");
fprintf(ExpressionFP,"%d,",exprPtr->type);
fprintf(ExpressionFP,"VS ");
switch (exprPtr->type)
{
case FCALL:
PrintFunctionReference(ExpressionFP,(struct FunctionDefinition *) exprPtr->value);
break;
case INTEGER:
PrintIntegerReference(ExpressionFP,(INTEGER_HN *) exprPtr->value);
break;
case FLOAT:
PrintFloatReference(ExpressionFP,(FLOAT_HN *) exprPtr->value);
break;
case PCALL:
#if DEFFUNCTION_CONSTRUCT
PrintDeffunctionReference(ExpressionFP,(DEFFUNCTION *) exprPtr->value,
ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case GCALL:
#if DEFGENERIC_CONSTRUCT
PrintGenericFunctionReference(ExpressionFP,(DEFGENERIC *) exprPtr->value,
ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFTEMPLATE_PTR:
#if DEFTEMPLATE_CONSTRUCT
DeftemplateCConstructReference(ExpressionFP,exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFGLOBAL_PTR:
#if DEFGLOBAL_CONSTRUCT
DefglobalCConstructReference(ExpressionFP,exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFCLASS_PTR:
#if OBJECT_SYSTEM
PrintClassReference(ExpressionFP,(DEFCLASS *) exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case FACT_ADDRESS:
#if DEFTEMPLATE_CONSTRUCT
fprintf(ExpressionFP,"&DummyFact");
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case INSTANCE_ADDRESS:
#if OBJECT_SYSTEM
fprintf(ExpressionFP,"&DummyInstance");
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case STRING:
case SYMBOL:
case INSTANCE_NAME:
case GBL_VARIABLE:
PrintSymbolReference(ExpressionFP,(SYMBOL_HN *) exprPtr->value);
break;
case RVOID:
fprintf(ExpressionFP,"NULL");
break;
default:
if (PrimitivesArray[exprPtr->type] == NULL)
{ fprintf(ExpressionFP,"NULL"); }
else if (PrimitivesArray[exprPtr->type]->bitMap)
{ PrintBitMapReference(ExpressionFP,(BITMAP_HN *) exprPtr->value); }
else
{ fprintf(ExpressionFP,"NULL"); }
break;
}
fprintf(ExpressionFP,",");
ExpressionCount++;
if (exprPtr->argList == NULL)
{ fprintf(ExpressionFP,"NULL,"); }
else
{
fprintf(ExpressionFP,"&E%d_%d[%ld],",ImageID,ExpressionVersion,
ExpressionCount);
}
if (exprPtr->nextArg == NULL)
{ fprintf(ExpressionFP,"NULL}"); }
else
{
fprintf(ExpressionFP,"&E%d_%d[%ld]}",ImageID,ExpressionVersion,
ExpressionCount + ExpressionSize(exprPtr->argList));
}
if (exprPtr->argList != NULL)
{
fprintf(ExpressionFP,",\n");
DumpExpression(exprPtr->argList);
}
exprPtr = exprPtr->nextArg;
if (exprPtr != NULL) fprintf(ExpressionFP,",\n");
}
}
static int FunctionsToCode(
char *fileName)
{
short i = 0;
FILE *fp;
int version = 1;
int newHeader = TRUE;
struct FunctionDefinition *fctnPtr;
/*=============================*/
/* Assign a reference index to */
/* each of the functions. */
/*=============================*/
for (fctnPtr = GetFunctionList();
fctnPtr != NULL;
fctnPtr = fctnPtr->next)
{ fctnPtr->bsaveIndex = i++; }
/*=======================================*/
/* Create the file in which to store the */
/* function definition data structures. */
/*=======================================*/
if ((fp = NewCFile(fileName,2,version,FALSE)) == NULL)
{ return(0); }
/*===============================================*/
/* Construct the definition of the function list */
/* from the definitions of the functions. */
/*===============================================*/
fprintf(fp,"\n\n");
fprintf(fp,"/************************************/\n");
fprintf(fp,"/* FUNCTION LIST DEFINITION */\n");
fprintf(fp,"/************************************/\n\n");
i = 1;
fctnPtr = GetFunctionList();
while (fctnPtr != NULL)
{
if (newHeader)
{
fprintf(fp,"struct FunctionDefinition P%d_%d[] = {\n",ImageID,version);
fprintf(HeaderFP,"extern struct FunctionDefinition P%d_%d[];\n",ImageID,version);
newHeader = FALSE;
}
fprintf(fp,"{");
PrintSymbolReference(fp,fctnPtr->callFunctionName);
fprintf(fp,",\"%s\",",fctnPtr->actualFunctionName);
fprintf(fp,"'%c',",fctnPtr->returnValueType);
fprintf(fp,"PTIF %s,",fctnPtr->actualFunctionName);
fprintf(fp,"NULL,");
if (fctnPtr->restrictions != NULL) fprintf(fp,"\"%s\",",fctnPtr->restrictions);
else fprintf(fp,"NULL,");
fprintf(fp,"0,0,0,");
PrintFunctionReference(fp,fctnPtr->next);
i++;
fctnPtr = fctnPtr->next;
if ((i > MaxIndices) || (fctnPtr == NULL))
{
fprintf(fp,"}};\n");
fclose(fp);
i = 1;
version++;
if (fctnPtr != NULL)
{
if ((fp = NewCFile(fileName,2,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,"},\n"); }
}
return(TRUE);
}
static int HashTablesToCode(
char *fileName)
{
int i;
FILE *fp;
struct symbolHashNode **symbolTable;
struct floatHashNode **floatTable;
struct integerHashNode **integerTable;
struct bitMapHashNode **bitMapTable;
#if FUZZY_DEFTEMPLATES
struct fuzzyValueHashNode **fuzzyValueTable;
#endif
/*======================================*/
/* Write the code for the symbol table. */
/*======================================*/
symbolTable = GetSymbolTable();
if ((fp = NewCFile(fileName,1,1,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,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,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,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);
#if FUZZY_DEFTEMPLATES
/*=============================*/
/* Dump the fuzzy value table. */
/*=============================*/
fuzzyValueTable = GetFuzzyValueTable();
if ((fp = NewCFile(fileName,1,5,FALSE)) == NULL) return(0);
fprintf(HeaderFP,"extern struct fuzzyValueHashNode *fvht%d[];\n",ImageID);
fprintf(fp,"struct fuzzyValueHashNode *fvht%d[%d] = {\n",ImageID,FUZZY_VALUE_HASH_SIZE);
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
PrintFuzzyValueReference(fp,fuzzyValueTable[i]);
if (i + 1 != FUZZY_VALUE_HASH_SIZE) fprintf(fp,",\n");
}
fprintf(fp,"};\n");
fclose(fp);
#endif /* FUZZY_DEFTEMPLATES */
return(1);
}
