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); }