static void CloseDeftemplateFiles(
void *theEnv,
FILE *moduleFile,
FILE *templateFile,
FILE *slotFile,
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
if (slotFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,slotFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (templateFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,templateFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (moduleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
static void CloseDefruleFiles(
void *theEnv,
FILE *moduleFile,
FILE *defruleFile,
FILE *joinFile,
FILE *linkFile,
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
if (linkFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,linkFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (joinFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,joinFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (defruleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,defruleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (moduleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
static int TraverseJoinLinks(
void *theEnv,
struct joinLink *linkPtr,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
FILE **linkFile,
int *fileCount,
int *linkArrayVersion,
int *linkArrayCount)
{
for (;
linkPtr != NULL;
linkPtr = linkPtr->next)
{
*linkFile = OpenFileIfNeeded(theEnv,*linkFile,fileName,pathName,fileNameBuffer,fileID,imageID,fileCount,
*linkArrayVersion,headerFP,
(char*)"struct joinLink",LinkPrefix(),FALSE,NULL);
if (*linkFile == NULL)
{ return(FALSE); }
LinkToCode(theEnv,*linkFile,linkPtr,imageID,maxIndices);
(*linkArrayCount)++;
*linkFile = CloseFileIfNeeded(theEnv,*linkFile,linkArrayCount,linkArrayVersion,
maxIndices,NULL,NULL);
}
return(TRUE);
}
static int RuleCompilerTraverseJoins(
void *theEnv,
EXEC_STATUS,
struct joinNode *joinPtr,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices,
FILE **joinFile,
FILE **linkFile,
int *fileCount,
int *joinArrayVersion,
int *joinArrayCount,
int *linkArrayVersion,
int *linkArrayCount)
{
for (;
joinPtr != NULL;
joinPtr = joinPtr->lastLevel)
{
if (joinPtr->marked)
{
*joinFile = OpenFileIfNeeded(theEnv,execStatus,*joinFile,fileName,pathName,fileNameBuffer,fileID,imageID,fileCount,
*joinArrayVersion,headerFP,
"struct joinNode",JoinPrefix(),FALSE,NULL);
if (*joinFile == NULL)
{ return(FALSE); }
JoinToCode(theEnv,execStatus,*joinFile,joinPtr,imageID,maxIndices);
(*joinArrayCount)++;
*joinFile = CloseFileIfNeeded(theEnv,execStatus,*joinFile,joinArrayCount,joinArrayVersion,
maxIndices,NULL,NULL);
if (! TraverseJoinLinks(theEnv,execStatus,joinPtr->nextLinks,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,
maxIndices,linkFile,fileCount,linkArrayVersion,linkArrayCount))
{ return(FALSE); }
}
if (joinPtr->joinFromTheRight)
{
if (RuleCompilerTraverseJoins(theEnv,execStatus,(struct joinNode *) joinPtr->rightSideEntryStructure,fileName,pathName,
fileNameBuffer,fileID,headerFP,imageID,maxIndices,joinFile,linkFile,fileCount,
joinArrayVersion,joinArrayCount,
linkArrayVersion,linkArrayCount) == FALSE)
{ return(FALSE); }
}
}
return(TRUE);
}
static void CloseDefglobalFiles(
Environment *theEnv,
FILE *moduleFile,
FILE *defglobalFile,
unsigned int maxIndices)
{
unsigned int count = maxIndices;
unsigned int arrayVersion = 0;
if (defglobalFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,defglobalFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (moduleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
/***************************************************
NAME : CloseDefinstancesFiles
DESCRIPTION : Closes construct compiler files
for definstances structures
INPUTS : 1) The definstances module file
2) The definstances structure file
3) The maximum number of indices
allowed in an array
RETURNS : Nothing useful
SIDE EFFECTS : Files closed
NOTES : None
***************************************************/
static void CloseDefinstancesFiles(
FILE *moduleFile,
FILE *definstancesFile,
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
if (definstancesFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(definstancesFile,&count,&arrayVersion,
maxIndices,NULL,NULL);
}
if (moduleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
static void CloseNetworkFiles(
FILE *networkFile,
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
if (networkFile != NULL)
{
CloseFileIfNeeded(networkFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
static void CloseDefglobalFiles(
void *theEnv,
EXEC_STATUS,
FILE *moduleFile,
FILE *defglobalFile,
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
if (defglobalFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,execStatus,defglobalFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
if (moduleFile != NULL)
{
count = maxIndices;
CloseFileIfNeeded(theEnv,execStatus,moduleFile,&count,&arrayVersion,maxIndices,NULL,NULL);
}
}
/******************************************************
NAME : CloseDefgenericFiles
DESCRIPTION : Closes construct compiler files
for defgeneric structures
INPUTS : 1) An array containing all the
pertinent file pointers
2) An array containing all the
pertinent file reopen flags
3) An array containing all the
pertinent file name/id/version info
4) The maximum number of indices
allowed in an array
RETURNS : Nothing useful
SIDE EFFECTS : Files closed
NOTES : None
*****************************************************/
static void CloseDefgenericFiles(
FILE *itemFiles[SAVE_ITEMS],
int itemReopenFlags[SAVE_ITEMS],
struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS],
int maxIndices)
{
int count = maxIndices;
int arrayVersion = 0;
register int i;
for (i = 0 ; i < SAVE_ITEMS ; i++)
{
count = maxIndices;
itemFiles[i] = CloseFileIfNeeded(itemFiles[i],&count,&arrayVersion,
maxIndices,&itemReopenFlags[i],
&itemCodeFiles[i]);
}
}
static int ConstructToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct defrule *theDefrule;
int joinArrayCount = 0, joinArrayVersion = 1;
int linkArrayCount = 0, linkArrayVersion = 1;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int defruleArrayCount = 0, defruleArrayVersion = 1;
FILE *joinFile = NULL, *moduleFile = NULL, *defruleFile = NULL, *linkFile = NULL;
/*==============================================*/
/* Include the appropriate defrule header file. */
/*==============================================*/
fprintf(headerFP,"#include \"ruledef.h\"\n");
/*======================================*/
/* Save the left and right prime links. */
/*======================================*/
if (! TraverseJoinLinks(theEnv,DefruleData(theEnv)->LeftPrimeJoins,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,
maxIndices,&linkFile,&fileCount,&linkArrayVersion,&linkArrayCount))
{
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(0);
}
if (! TraverseJoinLinks(theEnv,DefruleData(theEnv)->RightPrimeJoins,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,
maxIndices,&linkFile,&fileCount,&linkArrayVersion,&linkArrayCount))
{
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(0);
}
/*=========================================================*/
/* Loop through all the modules, all the defrules, and all */
/* the join nodes writing their C code representation to */
/* the file as they are traversed. */
/*=========================================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
EnvSetCurrentModule(theEnv,(void *) theModule);
/*==========================*/
/* Save the defrule module. */
/*==========================*/
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
(char*)"struct defruleModule",ModulePrefix(DefruleData(theEnv)->DefruleCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(0);
}
DefruleModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
/*=========================================*/
/* Loop through all of the defrules (and */
/* their disjuncts) in the current module. */
/*=========================================*/
theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,NULL);
while (theDefrule != NULL)
{
/*===================================*/
/* Save the defrule data structures. */
/*===================================*/
defruleFile = OpenFileIfNeeded(theEnv,defruleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
defruleArrayVersion,headerFP,
(char*)"struct defrule",ConstructPrefix(DefruleData(theEnv)->DefruleCodeItem),
FALSE,NULL);
if (defruleFile == NULL)
{
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(0);
}
DefruleToCode(theEnv,defruleFile,theDefrule,imageID,maxIndices,
moduleCount);
defruleArrayCount++;
defruleFile = CloseFileIfNeeded(theEnv,defruleFile,&defruleArrayCount,&defruleArrayVersion,
maxIndices,NULL,NULL);
/*================================*/
/* Save the join data structures. */
/*================================*/
if (! RuleCompilerTraverseJoins(theEnv,theDefrule->lastJoin,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,
maxIndices,&joinFile,&linkFile,&fileCount,&joinArrayVersion,&joinArrayCount,
&linkArrayVersion,&linkArrayCount))
{
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(0);
}
/*==========================================*/
/* Move on to the next disjunct or defrule. */
/*==========================================*/
if (theDefrule->disjunct != NULL) theDefrule = theDefrule->disjunct;
else theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,theDefrule);
}
moduleCount++;
moduleArrayCount++;
}
CloseDefruleFiles(theEnv,moduleFile,defruleFile,joinFile,linkFile,maxIndices);
return(1);
}
/*******************************************************
NAME : DefgenericsToCode
DESCRIPTION : Writes out static array code for
generic functions, methods, etc.
INPUTS : 1) The base name of the construct set
2) The base id for this construct
3) The file pointer for the header file
4) The base id for the construct set
5) The max number of indices allowed
in an array
RETURNS : -1 if no generic functions, 0 on errors,
1 if generic functions written
SIDE EFFECTS : Code written to files
NOTES : None
*******************************************************/
static int DefgenericsToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
DEFGENERIC *theDefgeneric;
DEFMETHOD *theMethod;
RESTRICTION *theRestriction;
register unsigned i,j,k;
int moduleCount = 0;
int itemArrayCounts[SAVE_ITEMS];
int itemArrayVersions[SAVE_ITEMS];
FILE *itemFiles[SAVE_ITEMS];
int itemReopenFlags[SAVE_ITEMS];
struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS];
for (i = 0 ; i < SAVE_ITEMS ; i++)
{
itemArrayCounts[i] = 0;
itemArrayVersions[i] = 1;
itemFiles[i] = NULL;
itemReopenFlags[i] = FALSE;
itemCodeFiles[i].filePrefix = NULL;
}
/* ===========================================
Include the appropriate generic header file
=========================================== */
fprintf(headerFP,"#include \"genrcfun.h\"\n");
/* =============================================================
Loop through all the modules and all the defgenerics writing
their C code representation to the file as they are traversed
============================================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((void *) theModule);
itemFiles[MODULEI] =
OpenFileIfNeeded(itemFiles[MODULEI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[MODULEI],headerFP,
"DEFGENERIC_MODULE",ModulePrefix(DefgenericCodeItem),
itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
if (itemFiles[MODULEI] == NULL)
goto GenericCodeError;
DefgenericModuleToCode(itemFiles[MODULEI],theModule,imageID,maxIndices);
itemFiles[MODULEI] =
CloseFileIfNeeded(itemFiles[MODULEI],&itemArrayCounts[MODULEI],
&itemArrayVersions[MODULEI],maxIndices,
&itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
theDefgeneric = (DEFGENERIC *) GetNextDefgeneric(NULL);
while (theDefgeneric != NULL)
{
itemFiles[GENERICI] =
OpenFileIfNeeded(itemFiles[GENERICI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[GENERICI],headerFP,
"DEFGENERIC",ConstructPrefix(DefgenericCodeItem),
itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
if (itemFiles[GENERICI] == NULL)
goto GenericCodeError;
SingleDefgenericToCode(itemFiles[GENERICI],imageID,maxIndices,theDefgeneric,
moduleCount,itemArrayVersions[METHODI],
itemArrayCounts[METHODI]);
itemArrayCounts[GENERICI]++;
itemFiles[GENERICI] =
CloseFileIfNeeded(itemFiles[GENERICI],&itemArrayCounts[GENERICI],
&itemArrayVersions[GENERICI],maxIndices,
&itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
if (theDefgeneric->mcnt > 0)
{
/* ===========================================
Make sure that all methods for a particular
generic function go into the same array
=========================================== */
itemFiles[METHODI] =
OpenFileIfNeeded(itemFiles[METHODI],fileName,fileID,imageID,&fileCount,
itemArrayVersions[METHODI],headerFP,
"DEFMETHOD",MethodPrefix(),
itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
if (itemFiles[METHODI] == NULL)
goto GenericCodeError;
for (i = 0 ; i < theDefgeneric->mcnt ; i++)
{
theMethod = &theDefgeneric->methods[i];
if (i > 0)
fprintf(itemFiles[METHODI],",\n");
MethodToCode(itemFiles[METHODI],imageID,theMethod,
itemArrayVersions[RESTRICTIONI],itemArrayCounts[RESTRICTIONI]);
if (theMethod->restrictionCount > 0)
{
/* ========================================
Make sure that all restrictions for a
particular method go into the same array
======================================== */
itemFiles[RESTRICTIONI] =
OpenFileIfNeeded(itemFiles[RESTRICTIONI],fileName,fileID,
imageID,&fileCount,
itemArrayVersions[RESTRICTIONI],headerFP,
"RESTRICTION",RestrictionPrefix(),
itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
if (itemFiles[RESTRICTIONI] == NULL)
goto GenericCodeError;
for (j = 0 ; j < theMethod->restrictionCount ; j++)
{
theRestriction = &theMethod->restrictions[j];
if (j > 0)
fprintf(itemFiles[RESTRICTIONI],",\n");
RestrictionToCode(itemFiles[RESTRICTIONI],imageID,theRestriction,
itemArrayVersions[TYPEI],itemArrayCounts[TYPEI]);
if (theRestriction->tcnt > 0)
{
/* =========================================
Make sure that all types for a particular
restriction go into the same array
========================================= */
itemFiles[TYPEI] =
OpenFileIfNeeded(itemFiles[TYPEI],fileName,fileID,
imageID,&fileCount,
itemArrayVersions[TYPEI],headerFP,
"void *",TypePrefix(),
itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
if (itemFiles[TYPEI] == NULL)
goto GenericCodeError;
for (k = 0 ; k < theRestriction->tcnt ; k++)
{
if (k > 0)
fprintf(itemFiles[TYPEI],",\n");
TypeToCode(itemFiles[TYPEI],imageID,
theRestriction->types[k],maxIndices);
}
itemArrayCounts[TYPEI] += theRestriction->tcnt;
itemFiles[TYPEI] =
CloseFileIfNeeded(itemFiles[TYPEI],&itemArrayCounts[TYPEI],
&itemArrayVersions[TYPEI],maxIndices,
&itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
}
}
itemArrayCounts[RESTRICTIONI] += theMethod->restrictionCount;
itemFiles[RESTRICTIONI] =
CloseFileIfNeeded(itemFiles[RESTRICTIONI],&itemArrayCounts[RESTRICTIONI],
&itemArrayVersions[RESTRICTIONI],maxIndices,
&itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
}
}
itemArrayCounts[METHODI] += theDefgeneric->mcnt;
itemFiles[METHODI] =
CloseFileIfNeeded(itemFiles[METHODI],&itemArrayCounts[METHODI],
&itemArrayVersions[METHODI],maxIndices,
&itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
}
theDefgeneric = (DEFGENERIC *) GetNextDefgeneric(theDefgeneric);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
moduleCount++;
itemArrayCounts[MODULEI]++;
}
CloseDefgenericFiles(itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
return(1);
GenericCodeError:
CloseDefgenericFiles(itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
return(0);
}
static int ConstructToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct deftemplate *theTemplate;
struct templateSlot *slotPtr;
int slotCount = 0, slotArrayCount = 0, slotArrayVersion = 1;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int templateArrayCount = 0, templateArrayVersion = 1;
FILE *slotFile = NULL, *moduleFile = NULL, *templateFile = NULL;
/*==================================================*/
/* Include the appropriate deftemplate header file. */
/*==================================================*/
fprintf(headerFP,"#include \"tmpltdef.h\"\n");
/*=============================================================*/
/* Loop through all the modules, all the deftemplates, and all */
/* the deftemplate slots writing their C code representation */
/* to the file as they are traversed. */
/*=============================================================*/
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
(char*)"struct deftemplateModule",ModulePrefix(DeftemplateData(theEnv)->DeftemplateCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
CloseDeftemplateFiles(theEnv,moduleFile,templateFile,slotFile,maxIndices);
return(0);
}
DeftemplateModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
/*=======================================================*/
/* Loop through each of the deftemplates in this module. */
/*=======================================================*/
theTemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,NULL);
while (theTemplate != NULL)
{
templateFile = OpenFileIfNeeded(theEnv,templateFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
templateArrayVersion,headerFP,
(char*)"struct deftemplate",ConstructPrefix(DeftemplateData(theEnv)->DeftemplateCodeItem),
FALSE,NULL);
if (templateFile == NULL)
{
CloseDeftemplateFiles(theEnv,moduleFile,templateFile,slotFile,maxIndices);
return(0);
}
DeftemplateToCode(theEnv,templateFile,theTemplate,imageID,maxIndices,
moduleCount,slotCount);
templateArrayCount++;
templateFile = CloseFileIfNeeded(theEnv,templateFile,&templateArrayCount,&templateArrayVersion,
maxIndices,NULL,NULL);
/*======================================================*/
/* Loop through each of the slots for this deftemplate. */
/*======================================================*/
slotPtr = theTemplate->slotList;
while (slotPtr != NULL)
{
slotFile = OpenFileIfNeeded(theEnv,slotFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
slotArrayVersion,headerFP,
(char*)"struct templateSlot",SlotPrefix(),FALSE,NULL);
if (slotFile == NULL)
{
CloseDeftemplateFiles(theEnv,moduleFile,templateFile,slotFile,maxIndices);
return(0);
}
SlotToCode(theEnv,slotFile,slotPtr,imageID,maxIndices,slotCount);
slotCount++;
slotArrayCount++;
slotFile = CloseFileIfNeeded(theEnv,slotFile,&slotArrayCount,&slotArrayVersion,
maxIndices,NULL,NULL);
slotPtr = slotPtr->next;
}
theTemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,theTemplate);
}
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule);
moduleCount++;
moduleArrayCount++;
}
CloseDeftemplateFiles(theEnv,moduleFile,templateFile,slotFile,maxIndices);
return(1);
}
static bool ConstructToCode(
Environment *theEnv,
const char *fileName,
const char *pathName,
char *fileNameBuffer,
unsigned int fileID,
FILE *headerFP,
unsigned int imageID,
unsigned int maxIndices)
{
unsigned int fileCount = 1;
Defmodule *theModule;
Deffacts *theDeffacts;
unsigned int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
unsigned int deffactsArrayCount = 0, deffactsArrayVersion = 1;
FILE *moduleFile = NULL, *deffactsFile = NULL;
/*===============================================*/
/* Include the appropriate deffacts header file. */
/*===============================================*/
fprintf(headerFP,"#include \"dffctdef.h\"\n");
/*=================================================================*/
/* Loop through all the modules and all the deffacts writing their */
/* C code representation to the file as they are traversed. */
/*=================================================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"struct deffactsModule",ModulePrefix(DeffactsData(theEnv)->DeffactsCodeItem),
false,NULL);
if (moduleFile == NULL)
{
CloseDeffactsFiles(theEnv,moduleFile,deffactsFile,maxIndices);
return false;
}
DeffactsModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
/*===================================================*/
/* Loop through each of the deffacts in this module. */
/*===================================================*/
for (theDeffacts = GetNextDeffacts(theEnv,NULL);
theDeffacts != NULL;
theDeffacts = GetNextDeffacts(theEnv,theDeffacts))
{
deffactsFile = OpenFileIfNeeded(theEnv,deffactsFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
deffactsArrayVersion,headerFP,
"Deffacts",ConstructPrefix(DeffactsData(theEnv)->DeffactsCodeItem),
false,NULL);
if (deffactsFile == NULL)
{
CloseDeffactsFiles(theEnv,moduleFile,deffactsFile,maxIndices);
return false;
}
DeffactsToCode(theEnv,deffactsFile,theDeffacts,imageID,maxIndices,moduleCount);
deffactsArrayCount++;
deffactsFile = CloseFileIfNeeded(theEnv,deffactsFile,&deffactsArrayCount,
&deffactsArrayVersion,maxIndices,NULL,NULL);
}
moduleCount++;
moduleArrayCount++;
}
CloseDeffactsFiles(theEnv,moduleFile,deffactsFile,maxIndices);
return true;
}
static int ConstructToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct defrule *theDefrule;
struct joinNode *theJoin;
int joinArrayCount = 0, joinArrayVersion = 1;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int defruleArrayCount = 0, defruleArrayVersion = 1;
FILE *joinFile = NULL, *moduleFile = NULL, *defruleFile = NULL;
#if FUZZY_DEFTEMPLATES
struct fzSlotLocator *thePatternFv;
int patternFvArrayCount = 0, patternFvArrayVersion = 1;
FILE *patternFvFile = NULL;
#endif
/*==============================================*/
/* Include the appropriate defrule header file. */
/*==============================================*/
fprintf(headerFP,"#include \"ruledef.h\"\n");
/*=========================================================*/
/* Loop through all the modules, all the defrules, and all */
/* the join nodes writing their C code representation to */
/* the file as they are traversed. */
/*=========================================================*/
#if FUZZY_DEFTEMPLATES
/*=========================================================*/
/* ALSO write the patternFv arrays as required if Fuzzy */
/*=========================================================*/
#endif
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
SetCurrentModule((void *) theModule);
/*==========================*/
/* Save the defrule module. */
/*==========================*/
moduleFile = OpenFileIfNeeded(moduleFile,fileName,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"struct defruleModule",ModulePrefix(DefruleCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
DefruleModuleToCode(moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
/*=========================================*/
/* Loop through all of the defrules (and */
/* their disjuncts) in the current module. */
/*=========================================*/
theDefrule = (struct defrule *) GetNextDefrule(NULL);
while (theDefrule != NULL)
{
/*===================================*/
/* Save the defrule data structures. */
/*===================================*/
defruleFile = OpenFileIfNeeded(defruleFile,fileName,fileID,imageID,&fileCount,
defruleArrayVersion,headerFP,
"struct defrule",ConstructPrefix(DefruleCodeItem),
FALSE,NULL);
if (defruleFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
#if FUZZY_DEFTEMPLATES
DefruleToCode(defruleFile,theDefrule,imageID,maxIndices,
moduleCount, patternFvArrayCount, patternFvArrayVersion);
#else
DefruleToCode(defruleFile,theDefrule,imageID,maxIndices,
moduleCount);
#endif
defruleArrayCount++;
defruleFile = CloseFileIfNeeded(defruleFile,&defruleArrayCount,&defruleArrayVersion,
maxIndices,NULL,NULL);
#if FUZZY_DEFTEMPLATES
/* write out the patternFv array of fzSlotLocator structs */
thePatternFv = theDefrule->pattern_fv_arrayPtr;
if (thePatternFv != NULL)
{
int i;
int numFzSlots = theDefrule->numberOfFuzzySlots;
patternFvFile = OpenFileIfNeeded(patternFvFile,fileName,fileID,imageID,&fileCount,
patternFvArrayVersion,headerFP,
"struct fzSlotLocator",PatternFvPrefix(),FALSE,NULL);
if (patternFvFile == NULL)
{
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
return(0);
}
for (i=0; i< numFzSlots; i++)
{
fprintf(patternFvFile, "{%d, %d, ",
thePatternFv[i].patternNum, thePatternFv[i].slotNum);
PrintFuzzyValueReference(patternFvFile,thePatternFv[i].fvhnPtr);
fprintf(patternFvFile, "}");
if (i != numFzSlots-1)
fprintf(patternFvFile, ",");
}
patternFvArrayCount += numFzSlots;
patternFvFile = CloseFileIfNeeded(patternFvFile,&patternFvArrayCount,&patternFvArrayVersion,
maxIndices,NULL,NULL);
}
#endif
/*================================*/
/* Save the join data structures. */
/*================================*/
for (theJoin = theDefrule->lastJoin;
theJoin != NULL;
theJoin = GetPreviousJoin(theJoin))
{
if (theJoin->marked)
{
joinFile = OpenFileIfNeeded(joinFile,fileName,fileID,imageID,&fileCount,
joinArrayVersion,headerFP,
"struct joinNode",JoinPrefix(),FALSE,NULL);
if (joinFile == NULL)
{
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
return(0);
}
JoinToCode(joinFile,theJoin,imageID,maxIndices);
joinArrayCount++;
joinFile = CloseFileIfNeeded(joinFile,&joinArrayCount,&joinArrayVersion,
maxIndices,NULL,NULL);
}
}
/*==========================================*/
/* Move on to the next disjunct or defrule. */
/*==========================================*/
if (theDefrule->disjunct != NULL) theDefrule = theDefrule->disjunct;
else theDefrule = (struct defrule *) GetNextDefrule(theDefrule);
}
moduleCount++;
moduleArrayCount++;
}
#if FUZZY_DEFTEMPLATES
CloseDefruleFiles(moduleFile,defruleFile,joinFile,patternFvFile,maxIndices);
#else
CloseDefruleFiles(moduleFile,defruleFile,joinFile,maxIndices);
#endif
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);
}
/*******************************************************
NAME : DeffunctionsToCode
DESCRIPTION : Writes out static array code for
deffunctions
INPUTS : 1) The base name of the construct set
2) The base id for this construct
3) The file pointer for the header file
4) The base id for the construct set
5) The max number of indices allowed
in an array
RETURNS : 0 on errors,
1 if deffunctions written
SIDE EFFECTS : Code written to files
NOTES : None
*******************************************************/
static bool DeffunctionsToCode(
void *theEnv,
const char *fileName,
const char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
DEFFUNCTION *theDeffunction;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int deffunctionArrayCount = 0, deffunctionArrayVersion = 1;
FILE *moduleFile = NULL, *deffunctionFile = NULL;
/* ===============================================
Include the appropriate deffunction header file
=============================================== */
fprintf(headerFP,"#include \"dffnxfun.h\"\n");
/* =============================================================
Loop through all the modules and all the deffunctions writing
their C code representation to the file as they are traversed
============================================================= */
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"DEFFUNCTION_MODULE",ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
false,NULL);
if (moduleFile == NULL)
{
CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
return(false);
}
DeffunctionModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
theDeffunction = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,NULL);
while (theDeffunction != NULL)
{
deffunctionFile = OpenFileIfNeeded(theEnv,deffunctionFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
deffunctionArrayVersion,headerFP,
"DEFFUNCTION",ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),
false,NULL);
if (deffunctionFile == NULL)
{
CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
return(false);
}
SingleDeffunctionToCode(theEnv,deffunctionFile,theDeffunction,imageID,
maxIndices,moduleCount);
deffunctionArrayCount++;
deffunctionFile = CloseFileIfNeeded(theEnv,deffunctionFile,&deffunctionArrayCount,
&deffunctionArrayVersion,maxIndices,NULL,NULL);
theDeffunction = (DEFFUNCTION *) EnvGetNextDeffunction(theEnv,theDeffunction);
}
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule);
moduleCount++;
moduleArrayCount++;
}
CloseDeffunctionFiles(theEnv,moduleFile,deffunctionFile,maxIndices);
return(true);
}
/*******************************************************
NAME : DefinstancesToCode
DESCRIPTION : Writes out static array code for
definstances
INPUTS : 1) The base name of the construct set
2) The base id for this construct
3) The file pointer for the header file
4) The base id for the construct set
5) The max number of indices allowed
in an array
RETURNS : -1 if no definstances, 0 on errors,
1 if definstances written
SIDE EFFECTS : Code written to files
NOTES : None
*******************************************************/
static int DefinstancesToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
DEFINSTANCES *theDefinstances;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int definstancesArrayCount = 0, definstancesArrayVersion = 1;
FILE *moduleFile = NULL, *definstancesFile = NULL;
/* ================================================
Include the appropriate definstances header file
================================================ */
fprintf(headerFP,"#include \"defins.h\"\n");
/* =============================================================
Loop through all the modules and all the definstances writing
their C code representation to the file as they are traversed
============================================================= */
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
(char*)"DEFINSTANCES_MODULE",ModulePrefix(DefinstancesData(theEnv)->DefinstancesCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
CloseDefinstancesFiles(theEnv,moduleFile,definstancesFile,maxIndices);
return(0);
}
DefinstancesModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
theDefinstances = (DEFINSTANCES *) EnvGetNextDefinstances(theEnv,NULL);
while (theDefinstances != NULL)
{
definstancesFile = OpenFileIfNeeded(theEnv,definstancesFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
definstancesArrayVersion,headerFP,
(char*)"DEFINSTANCES",ConstructPrefix(DefinstancesData(theEnv)->DefinstancesCodeItem),
FALSE,NULL);
if (definstancesFile == NULL)
{
CloseDefinstancesFiles(theEnv,moduleFile,definstancesFile,maxIndices);
return(0);
}
SingleDefinstancesToCode(theEnv,definstancesFile,theDefinstances,imageID,
maxIndices,moduleCount);
definstancesArrayCount++;
definstancesFile = CloseFileIfNeeded(theEnv,definstancesFile,&definstancesArrayCount,
&definstancesArrayVersion,maxIndices,NULL,NULL);
theDefinstances = (DEFINSTANCES *) EnvGetNextDefinstances(theEnv,theDefinstances);
}
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule);
moduleCount++;
moduleArrayCount++;
}
CloseDefinstancesFiles(theEnv,moduleFile,definstancesFile,maxIndices);
return(1);
}
static int PatternNetworkToCode(
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct deftemplate *theTemplate;
struct factPatternNode *thePatternNode;
int networkArrayCount = 0, networkArrayVersion = 1;
FILE *networkFile = NULL;
/*===========================================================*/
/* Include the appropriate fact pattern network header file. */
/*===========================================================*/
fprintf(headerFP,"#include \"factbld.h\"\n");
/*===============================*/
/* Loop through all the modules. */
/*===============================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*=========================*/
/* Set the current module. */
/*=========================*/
SetCurrentModule((void *) theModule);
/*======================================*/
/* Loop through all of the deftemplates */
/* in the current module. */
/*======================================*/
for (theTemplate = (struct deftemplate *) GetNextDeftemplate(NULL);
theTemplate != NULL;
theTemplate = (struct deftemplate *) GetNextDeftemplate(theTemplate))
{
/*======================================================*/
/* Loop through each pattern node in the deftemplate's */
/* pattern network writing its C code representation to */
/* the file as it is traversed. */
/*======================================================*/
for (thePatternNode = theTemplate->patternNetwork;
thePatternNode != NULL;
thePatternNode = GetNextPatternNode(thePatternNode))
{
networkFile = OpenFileIfNeeded(networkFile,fileName,fileID,imageID,&fileCount,
networkArrayVersion,headerFP,
"struct factPatternNode",FactPrefix(),FALSE,NULL);
if (networkFile == NULL)
{
CloseNetworkFiles(networkFile,maxIndices);
return(0);
}
PatternNodeToCode(networkFile,thePatternNode,imageID,maxIndices);
networkArrayCount++;
networkFile = CloseFileIfNeeded(networkFile,&networkArrayCount,
&networkArrayVersion,maxIndices,NULL,NULL);
}
}
}
/*==============================*/
/* Close any C files left open. */
/*==============================*/
CloseNetworkFiles(networkFile,maxIndices);
/*===============================*/
/* Return TRUE to indicate the C */
/* code was successfully saved. */
/*===============================*/
return(TRUE);
}
static int ConstructToCode(
void *theEnv,
char *fileName,
char *pathName,
char *fileNameBuffer,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int fileCount = 1;
struct defmodule *theModule;
struct defglobal *theDefglobal;
int moduleCount = 0, moduleArrayCount = 0, moduleArrayVersion = 1;
int defglobalArrayCount = 0, defglobalArrayVersion = 1;
FILE *moduleFile = NULL, *defglobalFile = NULL;
/*================================================*/
/* Include the appropriate defglobal header file. */
/*================================================*/
fprintf(headerFP,"#include \"globldef.h\"\n");
/*===================================================================*/
/* Loop through all the modules and all the defglobals writing their */
/* C code representation to the file as they are traversed. */
/*===================================================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleFile = OpenFileIfNeeded(theEnv,moduleFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
moduleArrayVersion,headerFP,
"struct defglobalModule",ModulePrefix(DefglobalData(theEnv)->DefglobalCodeItem),
FALSE,NULL);
if (moduleFile == NULL)
{
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return(0);
}
DefglobalModuleToCode(theEnv,moduleFile,theModule,imageID,maxIndices,moduleCount);
moduleFile = CloseFileIfNeeded(theEnv,moduleFile,&moduleArrayCount,&moduleArrayVersion,
maxIndices,NULL,NULL);
for (theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,theDefglobal))
{
defglobalFile = OpenFileIfNeeded(theEnv,defglobalFile,fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
defglobalArrayVersion,headerFP,
"struct defglobal",ConstructPrefix(DefglobalData(theEnv)->DefglobalCodeItem),
FALSE,NULL);
if (defglobalFile == NULL)
{
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return(0);
}
DefglobalToCode(theEnv,defglobalFile,theDefglobal,imageID,maxIndices,moduleCount);
defglobalArrayCount++;
defglobalFile = CloseFileIfNeeded(theEnv,defglobalFile,&defglobalArrayCount,
&defglobalArrayVersion,maxIndices,NULL,NULL);
}
moduleCount++;
moduleArrayCount++;
}
CloseDefglobalFiles(theEnv,moduleFile,defglobalFile,maxIndices);
return(1);
}
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));
}