globle int ExpressionToCode(
FILE *fp,
struct expr *exprPtr)
{
/*========================================*/
/* Print the reference to the expression. */
/*========================================*/
if (exprPtr == NULL)
{
if (fp != NULL) fprintf(fp,"NULL");
return(FALSE);
}
else if (fp != NULL)
{ fprintf(fp,"&E%d_%d[%ld]",ImageID,ExpressionVersion,ExpressionCount); }
/*==================================================*/
/* Create a new expression code file, if necessary. */
/*==================================================*/
if (ExpressionHeader == TRUE)
{
if ((ExpressionFP = NewCFile(FilePrefix,3,ExpressionVersion,FALSE)) == NULL)
{ return(-1); }
fprintf(ExpressionFP,"struct expr E%d_%d[] = {\n",ImageID,ExpressionVersion);
fprintf(HeaderFP,"extern struct expr E%d_%d[];\n",ImageID,ExpressionVersion);
ExpressionHeader = FALSE;
}
else
{ fprintf(ExpressionFP,",\n"); }
/*===========================*/
/* Dump the expression code. */
/*===========================*/
DumpExpression(exprPtr);
/*=========================================*/
/* Close the expression file if necessary. */
/*=========================================*/
if (ExpressionCount >= MaxIndices)
{
ExpressionCount = 0;
ExpressionVersion++;
fprintf(ExpressionFP,"};\n");
fclose(ExpressionFP);
ExpressionFP = NULL;
ExpressionHeader = TRUE;
}
/*==========================================*/
/* Return TRUE to indicate the expression */
/* reference and expression data structures */
/* were succcessfully written to the file. */
/*==========================================*/
return(TRUE);
}
globle int ConstraintsToCode(
void *theEnv,
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int i, j, count;
int newHeader = TRUE;
FILE *fp;
int version = 1;
int arrayVersion = 1;
unsigned short numberOfConstraints = 0;
CONSTRAINT_RECORD *tmpPtr;
/*===============================================*/
/* Count the total number of constraint records. */
/*===============================================*/
for (i = 0 ; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{ tmpPtr->bsaveIndex = numberOfConstraints++; }
}
/*=====================================================*/
/* If dynamic constraint checking is disabled, then */
/* contraints won't be saved. If there are constraints */
/* which could be saved, then issue a warning message. */
/*=====================================================*/
if ((! EnvGetDynamicConstraintChecking(theEnv)) && (numberOfConstraints != 0))
{
numberOfConstraints = 0;
PrintWarningID(theEnv,"CSTRNCMP",1,FALSE);
EnvPrintRouter(theEnv,WWARNING,"Constraints are not saved with a constructs-to-c image\n");
EnvPrintRouter(theEnv,WWARNING," when dynamic constraint checking is disabled.\n");
}
if (numberOfConstraints == 0) return(-1);
/*=================================================*/
/* Print the extern definition in the header file. */
/*=================================================*/
for (i = 1; i <= (numberOfConstraints / maxIndices) + 1 ; i++)
{ fprintf(headerFP,"extern CONSTRAINT_RECORD C%d_%d[];\n",imageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
count = 0;
for (i = 0; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{
if (newHeader)
{
fprintf(fp,"CONSTRAINT_RECORD C%d_%d[] = {\n",imageID,arrayVersion);
newHeader = FALSE;
}
fprintf(fp,"{%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
tmpPtr->anyAllowed,
tmpPtr->symbolsAllowed,
tmpPtr->stringsAllowed,
tmpPtr->floatsAllowed,
tmpPtr->integersAllowed,
tmpPtr->instanceNamesAllowed,
tmpPtr->instanceAddressesAllowed,
tmpPtr->externalAddressesAllowed,
tmpPtr->factAddressesAllowed,
0, /* void allowed */
tmpPtr->anyRestriction,
tmpPtr->symbolRestriction,
tmpPtr->stringRestriction,
tmpPtr->floatRestriction,
tmpPtr->integerRestriction,
tmpPtr->instanceNameRestriction,
tmpPtr->multifieldsAllowed,
tmpPtr->singlefieldsAllowed);
fprintf(fp,",0,"); /* bsaveIndex */
PrintHashedExpressionReference(theEnv,fp,tmpPtr->restrictionList,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->minValue,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->maxValue,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->minFields,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->maxFields,imageID,maxIndices);
/* multifield slot */
fprintf(fp,",NULL");
/* next slot */
if (tmpPtr->next == NULL)
{ fprintf(fp,",NULL,"); }
else
{
if ((j + 1) >= maxIndices)
{ fprintf(fp,",&C%d_%d[%d],",imageID,arrayVersion + 1,0); }
else
{ fprintf(fp,",&C%d_%d[%d],",imageID,arrayVersion,j + 1); }
}
fprintf(fp,"%d,%d",tmpPtr->bucket,tmpPtr->count + 1);
count++;
j++;
if ((count == numberOfConstraints) || (j >= maxIndices))
{
fprintf(fp,"}};\n");
GenClose(fp);
j = 0;
version++;
arrayVersion++;
if (count < numberOfConstraints)
{
if ((fp = NewCFile(theEnv,fileName,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,"},\n"); }
}
}
return(version);
}
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 int IntegerHashNodesToCode(
void *theEnv,
const char *fileName,
const char *pathName,
char *fileNameBuffer,
int version)
{
int i, j;
struct integerHashNode *hashPtr;
int count;
int numberOfEntries;
struct integerHashNode **integerTable;
bool newHeader = true;
FILE *fp;
int arrayVersion = 1;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
integerTable = GetIntegerTable(theEnv);
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 / ConstructCompilerData(theEnv)->MaxIndices) + 1 ; i++)
{ fprintf(ConstructCompilerData(theEnv)->HeaderFP,"extern struct integerHashNode I%d_%d[];\n",ConstructCompilerData(theEnv)->ImageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,fileName,pathName,fileNameBuffer,1,version,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",ConstructCompilerData(theEnv)->ImageID,arrayVersion);
newHeader = false;
}
if (hashPtr->next == NULL)
{ fprintf(fp,"{NULL,"); }
else
{
if ((j + 1) >= ConstructCompilerData(theEnv)->MaxIndices)
{ fprintf(fp,"{&I%d_%d[%d],",ConstructCompilerData(theEnv)->ImageID,arrayVersion + 1,0); }
else
{ fprintf(fp,"{&I%d_%d[%d],",ConstructCompilerData(theEnv)->ImageID,arrayVersion,j + 1); }
}
fprintf(fp,"%ld,1,0,0,%d,",hashPtr->count + 1,i);
fprintf(fp,"%lldLL",hashPtr->contents);
count++;
j++;
if ((count == numberOfEntries) || (j >= ConstructCompilerData(theEnv)->MaxIndices))
{
fprintf(fp,"}};\n");
GenClose(theEnv,fp);
j = 0;
version++;
arrayVersion++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(theEnv,fileName,pathName,fileNameBuffer,1,version,false)) == NULL) return(0);
newHeader = true;
}
}
else
{ fprintf(fp,"},\n"); }
}
}
return(version);
}
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);
}
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);
}
/***********************************************************
NAME : AlphaPatternNodesToCode
DESCRIPTION : Writes out data structures for run-time
creation of object pattern alpha memories
INPUTS : 1) The base image output file name
2) The base image file id
3) A pointer to the header output file
4) The id of constructs-to-c image
5) The maximum number of indices
allowed in any single array
in the image
RETURNS : Next version file to open, 0 if error
SIDE EFFECTS : Object patterns code written to files
NOTES : None
***********************************************************/
static int AlphaPatternNodesToCode(
void *theEnv,
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
int version)
{
FILE *fp;
int arrayVersion;
int newHeader;
int i;
OBJECT_ALPHA_NODE *thePattern;
/* ================
Create the file.
================ */
if (ObjectNetworkTerminalPointer(theEnv) == NULL)
return(version);
/* =================================
Dump the pattern node structures.
================================= */
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
arrayVersion = 1;
i = 1;
thePattern = ObjectNetworkTerminalPointer(theEnv);
while (thePattern != NULL)
{
if (newHeader)
{
fprintf(fp,"OBJECT_ALPHA_NODE %s%d_%d[] = {\n",
ObjectANPrefix(),imageID,arrayVersion);
fprintf(headerFP,"extern OBJECT_ALPHA_NODE %s%d_%d[];\n",
ObjectANPrefix(),imageID,arrayVersion);
newHeader = FALSE;
}
fprintf(fp,"{");
PatternNodeHeaderToCode(theEnv,fp,&thePattern->header,imageID,maxIndices);
fprintf(fp,",0L,");
PrintBitMapReference(theEnv,fp,thePattern->classbmp);
fprintf(fp,",");
PrintBitMapReference(theEnv,fp,thePattern->slotbmp);
fprintf(fp,",");
IntermediatePatternNodeReference(theEnv,thePattern->patternNode,fp,imageID,maxIndices);
fprintf(fp,",");
ObjectPatternNodeReference(theEnv,thePattern->nxtInGroup,fp,imageID,maxIndices);
fprintf(fp,",");
ObjectPatternNodeReference(theEnv,thePattern->nxtTerminal,fp,imageID,maxIndices);
fprintf(fp,",0L}");
i++;
thePattern = thePattern->nxtTerminal;
if ((i > maxIndices) || (thePattern == NULL))
{
fprintf(fp,"};\n");
GenClose(fp);
i = 1;
version++;
arrayVersion++;
if (thePattern != NULL)
{
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
}
}
else if (thePattern != NULL)
{ fprintf(fp,",\n"); }
}
return(version);
}
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 IntegerHashNodesToCode(
char *fileName,
int version)
{
int i, j;
struct integerHashNode *hashPtr;
int count;
int numberOfEntries;
struct integerHashNode **integerTable;
int newHeader = 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,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 = 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,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{
fprintf(fp,"},\n");
}
}
}
return(version);
}
/*************************************************************
NAME : IntermediatePatternNodesToCode
DESCRIPTION : Writes out data structures for run-time
creation of object pattern intermediate nodes
INPUTS : 1) The base image output file name
2) The base image file id
3) A pointer to the header output file
4) The id of constructs-to-c image
5) The maximum number of indices
allowed in any single array
in the image
RETURNS : Next version file to open, 0 if error
SIDE EFFECTS : Object patterns code written to files
NOTES : None
*************************************************************/
static int IntermediatePatternNodesToCode(
void *theEnv,
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
int version)
{
FILE *fp;
int arrayVersion;
int newHeader;
int i;
OBJECT_PATTERN_NODE *thePattern;
/* ================
Create the file.
================ */
if (ObjectNetworkPointer(theEnv) == NULL)
return(1);
fprintf(headerFP,"#include \"objrtmch.h\"\n");
/* =================================
Dump the pattern node structures.
================================= */
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
arrayVersion = 1;
i = 1;
thePattern = ObjectNetworkPointer(theEnv);
while (thePattern != NULL)
{
if (newHeader)
{
fprintf(fp,"OBJECT_PATTERN_NODE %s%d_%d[] = {\n",
ObjectPNPrefix(),imageID,arrayVersion);
fprintf(headerFP,"extern OBJECT_PATTERN_NODE %s%d_%d[];\n",
ObjectPNPrefix(),imageID,arrayVersion);
newHeader = FALSE;
}
fprintf(fp,"{0,%u,%u,%u,%u,0L,%u,",thePattern->multifieldNode,
thePattern->endSlot,
thePattern->whichField,
thePattern->leaveFields,
thePattern->slotNameID);
PrintHashedExpressionReference(theEnv,fp,thePattern->networkTest,imageID,maxIndices);
fprintf(fp,",");
IntermediatePatternNodeReference(theEnv,thePattern->nextLevel,fp,imageID,maxIndices);
fprintf(fp,",");
IntermediatePatternNodeReference(theEnv,thePattern->lastLevel,fp,imageID,maxIndices);
fprintf(fp,",");
IntermediatePatternNodeReference(theEnv,thePattern->leftNode,fp,imageID,maxIndices);
fprintf(fp,",");
IntermediatePatternNodeReference(theEnv,thePattern->rightNode,fp,imageID,maxIndices);
fprintf(fp,",");
ObjectPatternNodeReference(theEnv,(void *) thePattern->alphaNode,fp,imageID,maxIndices);
fprintf(fp,",0L}");
i++;
thePattern = GetNextObjectPatternNode(thePattern);
if ((i > maxIndices) || (thePattern == NULL))
{
fprintf(fp,"};\n");
GenClose(fp);
i = 1;
version++;
arrayVersion++;
if (thePattern != NULL)
{
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
}
}
else if (thePattern != NULL)
{ fprintf(fp,",\n"); }
}
return(version);
}
static int FuzzyValueArraysToCode(
char *fileName,
int version)
{
int i, j, k;
struct fuzzyValueHashNode *hashPtr;
int count;
int numberOfEntries;
struct fuzzyValueHashNode **fuzzyValueTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
int arraySize;
/*====================================*/
/* Count the total number of entries. */
/* i.e. total x and y values to be */
/* written */
/*====================================*/
fuzzyValueTable = GetFuzzyValueTable();
count = numberOfEntries = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
arraySize = hashPtr->contents->n;
numberOfEntries += arraySize + arraySize;
hashPtr = hashPtr->next;
}
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (numberOfEntries / MaxIndices) + 1 ; i++)
{
fprintf(HeaderFP,"extern double X%d_%d[];\n",ImageID,i);
}
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(-1);
/*=====================*/
/* Fillin the entries. */
/*=====================*/
j = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
if (newHeader)
{
fprintf(fp,"double X%d_%d[] = {\n",ImageID,arrayVersion);
newHeader = FALSE;
}
/* write out the x values then y values for each fuzzy value */
arraySize = hashPtr->contents->n;
for (k=0; k<arraySize-1; k++)
fprintf(fp,"%s,", FloatToString(hashPtr->contents->x[k]));
fprintf(fp,"%s,\n", FloatToString(hashPtr->contents->x[arraySize-1]));
for (k=0; k<arraySize-1; k++)
fprintf(fp,"%s,", FloatToString(hashPtr->contents->y[k]));
fprintf(fp,"%s", FloatToString(hashPtr->contents->y[arraySize-1]));
count += arraySize + arraySize;
j += arraySize + arraySize;
if ((count == numberOfEntries) || (j >= MaxIndices))
{
fprintf(fp,"};\n");
fclose(fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{
fprintf(fp,",\n");
}
hashPtr = hashPtr->next;
}
}
return(version);
}
static int FuzzyValuesToCode(
char *fileName,
int version)
{
int i, j;
struct fuzzyValueHashNode *hashPtr;
int count;
int numberOfEntries;
struct fuzzyValueHashNode **fuzzyValueTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
int arraySize;
int xyArrayPartition = 1, xyArrayPartitionCount = 0;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
fuzzyValueTable = GetFuzzyValueTable();
count = numberOfEntries = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
numberOfEntries++;
hashPtr = hashPtr->next;
}
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (numberOfEntries / MaxIndices) + 1 ; i++)
{
fprintf(HeaderFP,"extern struct fuzzy_value W%d_%d[];\n",ImageID,i);
}
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(-1);
/*=====================*/
/* Fillin the entries. */
/*=====================*/
j = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
if (newHeader)
{
fprintf(fp,"struct fuzzy_value W%d_%d[] = {\n",ImageID,arrayVersion);
newHeader = FALSE;
}
/* fill in the entries of the fuzzy value struct:
whichDeftemplate - ptr to deftemplate structure
name - char *
maxn - int
n - int
x - ptr to double (will be index into X array)
y - ptr to double (will be index into X array)
*/
fprintf(fp,"{");
DeftemplateCConstructReference(fp, hashPtr->contents->whichDeftemplate,
ImageID, MaxIndices);
fprintf(fp,",");
PrintCString(fp,hashPtr->contents->name);
/* NOTE: arraySize twice in next fprintf line is correct!
We don't want to store maxn value since we pack the arrays
when writing X array out to c file
*/
arraySize = hashPtr->contents->n;
fprintf(fp,",%d,%d", arraySize, arraySize);
fprintf(fp,",(double *)&X%d_%d[%d], (double *)&X%d_%d[%d]",
ImageID, xyArrayPartition, xyArrayPartitionCount,
ImageID, xyArrayPartition, xyArrayPartitionCount+arraySize);
xyArrayPartitionCount += arraySize + arraySize;
if (xyArrayPartitionCount >= MaxIndices)
{
xyArrayPartitionCount = 0;
xyArrayPartition++;
}
count++;
j++;
if ((count == numberOfEntries) || (j >= MaxIndices))
{
fprintf(fp,"}};\n");
fclose(fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{
fprintf(fp,"},\n");
}
hashPtr = hashPtr->next;
}
}
return(version);
}
static int FuzzyValueHashNodesToCode(
char *fileName,
int version)
{
int i, j;
struct fuzzyValueHashNode *hashPtr;
int count;
int numberOfEntries;
struct fuzzyValueHashNode **fuzzyValueTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
fuzzyValueTable = GetFuzzyValueTable();
count = numberOfEntries = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
numberOfEntries++;
hashPtr = hashPtr->next;
}
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (numberOfEntries / MaxIndices) + 1 ; i++)
{
fprintf(HeaderFP,"extern struct fuzzyValueHashNode V%d_%d[];\n",ImageID,i);
}
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
for (i = 0; i < FUZZY_VALUE_HASH_SIZE; i++)
{
hashPtr = fuzzyValueTable[i];
while (hashPtr != NULL)
{
if (newHeader)
{
fprintf(fp,"struct fuzzyValueHashNode V%d_%d[] = {\n",ImageID,arrayVersion);
newHeader = FALSE;
}
/* fill in 'next' slot in fuzzyValueHashNode struct */
if (hashPtr->next == NULL)
{
fprintf(fp,"{NULL,");
}
else
{
if ((j + 1) >= MaxIndices)
{
fprintf(fp,"{&V%d_%d[%d],",ImageID,arrayVersion + 1,0);
}
else
{
fprintf(fp,"{&V%d_%d[%d],",ImageID,arrayVersion,j + 1);
}
}
/* fill in other slots in fuzzyValueHashNode struct */
fprintf(fp,"%ld,0,0,0,%d,(struct fuzzy_value *) &W%d_%d[%d]",
hashPtr->count + 1,i,
ImageID,arrayVersion,j);
count++;
j++;
if ((count == numberOfEntries) || (j >= MaxIndices))
{
fprintf(fp,"}};\n");
fclose(fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(fileName,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{
fprintf(fp,"},\n");
}
hashPtr = hashPtr->next;
}
}
return(version);
}
static int BitMapHashNodesToCode(
void *theEnv,
EXEC_STATUS,
char *fileName,
char *pathName,
char *fileNameBuffer,
int version)
{
int i, j;
struct bitMapHashNode *hashPtr;
int count;
int numberOfEntries;
struct bitMapHashNode **bitMapTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
int longsReqdPartition = 1,longsReqdPartitionCount = 0;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
bitMapTable = GetBitMapTable(theEnv,execStatus);
count = numberOfEntries = 0;
for (i = 0; i < BITMAP_HASH_SIZE; i++)
{
for (hashPtr = bitMapTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{ numberOfEntries++; }
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (numberOfEntries / ConstructCompilerData(theEnv,execStatus)->MaxIndices) + 1 ; i++)
{ fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct bitMapHashNode B%d_%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
for (i = 0; i < BITMAP_HASH_SIZE; i++)
{
for (hashPtr = bitMapTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{
if (newHeader)
{
fprintf(fp,"struct bitMapHashNode B%d_%d[] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion);
newHeader = FALSE;
}
if (hashPtr->next == NULL)
{ fprintf(fp,"{NULL,"); }
else
{
if ((j + 1) >= ConstructCompilerData(theEnv,execStatus)->MaxIndices)
{ fprintf(fp,"{&B%d_%d[%d],",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion + 1,0); }
else
{ fprintf(fp,"{&B%d_%d[%d],",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion,j + 1); }
}
fprintf(fp,"%ld,0,1,0,0,%d,(char *) &L%d_%d[%d],%d",
hashPtr->count + 1,i,
ConstructCompilerData(theEnv,execStatus)->ImageID,longsReqdPartition,longsReqdPartitionCount,
hashPtr->size);
longsReqdPartitionCount += (int) (hashPtr->size / sizeof(unsigned long));
if ((hashPtr->size % sizeof(unsigned long)) != 0)
longsReqdPartitionCount++;
if (longsReqdPartitionCount >= ConstructCompilerData(theEnv,execStatus)->MaxIndices)
{
longsReqdPartitionCount = 0;
longsReqdPartition++;
}
count++;
j++;
if ((count == numberOfEntries) || (j >= ConstructCompilerData(theEnv,execStatus)->MaxIndices))
{
fprintf(fp,"}};\n");
GenClose(theEnv,execStatus,fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,"},\n"); }
}
}
return(version);
}
globle FILE *CloseFileIfNeeded(
FILE *theFile,
int *theCount,
int *arrayVersion,
int maxIndices,
int *canBeReopened,
struct CodeGeneratorFile *codeFile)
{
/*==========================================*/
/* If the maximum number of entries for the */
/* file hasn't been exceeded, then... */
/*==========================================*/
if (*theCount < maxIndices)
{
/*====================================*/
/* If the file can be reopened later, */
/* close it. Otherwise, keep it open. */
/*====================================*/
if (canBeReopened != NULL)
{
*canBeReopened = TRUE;
fclose(theFile);
return(NULL);
}
return(theFile);
}
/*===========================================*/
/* Otherwise, the number of entries allowed */
/* in a file has been reached. Indicate that */
/* the file can't be reopened. */
/*===========================================*/
if (canBeReopened != NULL)
{ *canBeReopened = FALSE; }
/*===============================================*/
/* If the file is closed, then we need to reopen */
/* it to print the final closing right brace. */
/*===============================================*/
if (theFile == NULL)
{
if ((canBeReopened == NULL) || (codeFile == NULL))
{
SystemError("CONSCOMP",3);
ExitRouter(EXIT_FAILURE);
}
if (codeFile->filePrefix == NULL)
{ return(NULL); }
theFile = NewCFile(codeFile->filePrefix,codeFile->id,codeFile->version,TRUE);
if (theFile == NULL)
{
SystemError("CONSCOMP",4);
ExitRouter(EXIT_FAILURE);
}
}
/*================================*/
/* Print the final closing brace. */
/*================================*/
fprintf(theFile,"};\n");
fclose(theFile);
/*============================================*/
/* Update index values for subsequent writing */
/* of data structures to files. */
/*============================================*/
*theCount = 0;
(*arrayVersion)++;
/*=========================*/
/* Return NULL to indicate */
/* the file is closed. */
/*=========================*/
return(NULL);
}
static int BitMapValuesToCode(
void *theEnv,
EXEC_STATUS,
char *fileName,
char *pathName,
char *fileNameBuffer,
int version)
{
int i, j, k;
unsigned l;
struct bitMapHashNode *hashPtr;
int count;
int numberOfEntries;
struct bitMapHashNode **bitMapTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
unsigned long tmpLong;
int longsReqd;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
bitMapTable = GetBitMapTable(theEnv,execStatus);
count = numberOfEntries = 0;
for (i = 0; i < BITMAP_HASH_SIZE; i++)
{
for (hashPtr = bitMapTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{
numberOfEntries += (int) (hashPtr->size / sizeof(unsigned long));
if ((hashPtr->size % sizeof(unsigned long)) != 0)
{ numberOfEntries++; }
}
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (numberOfEntries / ConstructCompilerData(theEnv,execStatus)->MaxIndices) + 1 ; i++)
{ fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern unsigned long L%d_%d[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
for (i = 0; i < BITMAP_HASH_SIZE; i++)
{
for (hashPtr = bitMapTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{
if (newHeader)
{
fprintf(fp,"unsigned long L%d_%d[] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion);
newHeader = FALSE;
}
longsReqd = (int) (hashPtr->size / sizeof(unsigned long));
if ((hashPtr->size % sizeof(unsigned long)) != 0)
longsReqd++;
for (k = 0 ; k < longsReqd ; k++)
{
if (k > 0)
fprintf(fp,",");
tmpLong = 0L;
for (l = 0 ;
((l < sizeof(unsigned long)) &&
(((k * sizeof(unsigned long)) + l) < (size_t) hashPtr->size)) ;
l++)
((char *) &tmpLong)[l] = hashPtr->contents[(k * sizeof(unsigned long)) + l];
fprintf(fp,"0x%lxL",tmpLong);
}
count += longsReqd;
j += longsReqd;
if ((count == numberOfEntries) || (j >= ConstructCompilerData(theEnv,execStatus)->MaxIndices))
{
fprintf(fp,"};\n");
GenClose(theEnv,execStatus,fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,",\n"); }
}
}
return(version);
}
globle FILE *OpenFileIfNeeded(
FILE *theFile,
char *fileName,
int fileID,
int imageID,
int *fileCount,
int arrayVersion,
FILE *headerFP,
char *structureName,
char *structPrefix,
int reopenOldFile,
struct CodeGeneratorFile *codeFile)
{
char arrayName[80];
char *newName;
int newID, newVersion;
/*===========================================*/
/* If a file is being reopened, use the same */
/* version number, name, and ID as before. */
/*===========================================*/
if (reopenOldFile)
{
if (codeFile == NULL)
{
SystemError("CONSCOMP",5);
ExitRouter(EXIT_FAILURE);
}
newName = codeFile->filePrefix;
newID = codeFile->id;
newVersion = codeFile->version;
}
/*=====================================================*/
/* Otherwise, use the specified version number, name, */
/* and ID. If the appropriate argument is supplied, */
/* remember these values for later reopening the file. */
/*=====================================================*/
else
{
newName = fileName;
newVersion = *fileCount;
newID = fileID;
if (codeFile != NULL)
{
codeFile->version = newVersion;
codeFile->filePrefix = newName;
codeFile->id = newID;
}
}
/*=========================================*/
/* If the file is already open, return it. */
/*=========================================*/
if (theFile != NULL)
{
fprintf(theFile,",\n");
return(theFile);
}
/*================*/
/* Open the file. */
/*================*/
if ((theFile = NewCFile(newName,newID,newVersion,reopenOldFile)) == NULL)
{ return(NULL); }
/*=========================================*/
/* If this is the first time the file has */
/* been opened, write out the beginning of */
/* the array variable definition. */
/*=========================================*/
if (reopenOldFile == FALSE)
{
(*fileCount)++;
sprintf(arrayName,"%s%d_%d",structPrefix,imageID,arrayVersion);
#if SHORT_LINK_NAMES
if (strlen(arrayName) > 6)
{
PrintWarningID("CONSCOMP",2,FALSE);
PrintRouter(WWARNING,"Array name ");
PrintRouter(WWARNING,arrayName);
PrintRouter(WWARNING,"exceeds 6 characters in length.\n");
PrintRouter(WWARNING," This variable may be indistinguishable from another by the linker.\n");
}
#endif
fprintf(theFile,"%s %s[] = {\n",structureName,arrayName);
fprintf(headerFP,"extern %s %s[];\n",structureName,arrayName);
}
else
{ fprintf(theFile,",\n"); }
/*==================*/
/* Return the file. */
/*==================*/
return(theFile);
}
static int SymbolHashNodesToCode(
void *theEnv,
EXEC_STATUS,
char *fileName,
char *pathName,
char *fileNameBuffer,
int version)
{
unsigned long i, j;
struct symbolHashNode *hashPtr;
int count;
int numberOfEntries;
struct symbolHashNode **symbolTable;
int newHeader = TRUE;
int arrayVersion = 1;
FILE *fp;
/*====================================*/
/* Count the total number of entries. */
/*====================================*/
symbolTable = GetSymbolTable(theEnv,execStatus);
count = numberOfEntries = 0;
for (i = 0; i < SYMBOL_HASH_SIZE; i++)
{
for (hashPtr = symbolTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{ numberOfEntries++; }
}
if (numberOfEntries == 0) return(version);
for (i = 1; i <= (unsigned long) (numberOfEntries / ConstructCompilerData(theEnv,execStatus)->MaxIndices) + 1 ; i++)
{ fprintf(ConstructCompilerData(theEnv,execStatus)->HeaderFP,"extern struct symbolHashNode S%d_%ld[];\n",ConstructCompilerData(theEnv,execStatus)->ImageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
for (i = 0; i < SYMBOL_HASH_SIZE; i++)
{
for (hashPtr = symbolTable[i];
hashPtr != NULL;
hashPtr = hashPtr->next)
{
if (newHeader)
{
fprintf(fp,"struct symbolHashNode S%d_%d[] = {\n",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion);
newHeader = FALSE;
}
if (hashPtr->next == NULL)
{ fprintf(fp,"{NULL,"); }
else
{
if ((j + 1) >= (unsigned long) ConstructCompilerData(theEnv,execStatus)->MaxIndices)
{ fprintf(fp,"{&S%d_%d[%d],",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion + 1,0); }
else
{ fprintf(fp,"{&S%d_%d[%ld],",ConstructCompilerData(theEnv,execStatus)->ImageID,arrayVersion,j + 1); }
}
fprintf(fp,"%ld,0,1,0,0,%ld,",hashPtr->count + 1,i);
PrintCString(fp,hashPtr->contents);
count++;
j++;
if ((count == numberOfEntries) || (j >= (unsigned) ConstructCompilerData(theEnv,execStatus)->MaxIndices))
{
fprintf(fp,"}};\n");
GenClose(theEnv,execStatus,fp);
j = 0;
arrayVersion++;
version++;
if (count < numberOfEntries)
{
if ((fp = NewCFile(theEnv,execStatus,fileName,pathName,fileNameBuffer,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,"},\n"); }
}
}
return(version);
}
/***********************************************************
NAME : ClassAlphaLinksToCode
DESCRIPTION : Writes out data structures for run-time
creation of class alpha link
INPUTS : 1) The base image output file name
2) The base image file id
3) A pointer to the header output file
4) The id of constructs-to-c image
5) The maximum number of indices
allowed in any single array
in the image
RETURNS : Next version file to open, 0 if error
SIDE EFFECTS : Class alpha links code written to files
NOTES : None
***********************************************************/
static int ClassAlphaLinksToCode(
void *theEnv,
const char *fileName,
const char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
int version)
{
FILE *fp;
int arrayVersion;
int newHeader;
int i;
struct defmodule *theModule = NULL;
DEFCLASS *theDefclass = NULL;
CLASS_ALPHA_LINK *theLink = NULL;
/* =================================
Dump the alpha link structures.
================================= */
if ((fp = NewCFile(theEnv,fileName,pathName,fileNameBuffer,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
arrayVersion = 1;
i = 1;
theLink = GetNextAlphaLink(theEnv,&theModule,&theDefclass,theLink);
while (theLink != NULL)
{
if (newHeader)
{
fprintf(fp,"CLASS_ALPHA_LINK %s%d_%d[] = {\n",
ObjectALPrefix(),imageID,arrayVersion);
fprintf(headerFP,"extern CLASS_ALPHA_LINK %s%d_%d[];\n",
ObjectALPrefix(),imageID,arrayVersion);
newHeader = FALSE;
}
fprintf(fp,"{");
ObjectPatternNodeReference(theEnv,theLink->alphaNode,fp,imageID,maxIndices);
fprintf(fp,",");
ClassAlphaLinkReference(theEnv,theLink->next,fp,imageID,maxIndices);
fprintf(fp,"}");
theLink = GetNextAlphaLink(theEnv,&theModule,&theDefclass,theLink);
if ((i > maxIndices) || (theLink == NULL))
{
fprintf(fp,"};\n");
GenClose(theEnv,fp);
i = 1;
version++;
arrayVersion++;
if (theLink != NULL)
{
if ((fp = NewCFile(theEnv,fileName,pathName,fileNameBuffer,fileID,version,FALSE)) == NULL)
return(0);
newHeader = TRUE;
}
}
else if (theLink != NULL)
{ fprintf(fp,",\n"); }
}
return(version);
}