/*******************************************************/ /* "C" Language Integrated Production System */ /* */ /* CLIPS Version 6.40 02/03/18 */ /* */ /* */ /*******************************************************/ /*************************************************************/ /* Purpose: Object System Construct Compiler Code */ /* */ /* Principal Programmer(s): */ /* Brian L. Dantes */ /* */ /* Contributing Programmer(s): */ /* */ /* Revision History: */ /* */ /* 6.24: Renamed BOOLEAN macro type to intBool. */ /* */ /* Added environment parameter to GenClose. */ /* */ /* 6.30: Changed integer type/precision. */ /* */ /* Removed conditional code for unsupported */ /* compilers/operating systems (IBM_MCW, */ /* MAC_MCW, and IBM_TBC). */ /* */ /* Added support for path name argument to */ /* constructs-to-c. */ /* */ /* Added const qualifiers to remove C++ */ /* deprecation warnings. */ /* */ /* 6.31: Optimization for marking relevant alpha nodes */ /* in the object pattern network. */ /* */ /* 6.40: Pragma once and other inclusion changes. */ /* */ /* Added support for booleans with . */ /* */ /* Removed use of void pointers for specific */ /* data structures. */ /* */ /* UDF redesign. */ /* */ /*************************************************************/ /* ========================================= ***************************************** EXTERNAL DEFINITIONS ========================================= ***************************************** */ #include "setup.h" #if OBJECT_SYSTEM && CONSTRUCT_COMPILER && (! RUN_TIME) #include "conscomp.h" #include "classcom.h" #include "classfun.h" #include "classini.h" #include "cstrncmp.h" #include "envrnmnt.h" #include "objrtfnx.h" #include "sysdep.h" #if DEFRULE_CONSTRUCT #include "objrtcmp.h" #endif #include "objcmp.h" /* ========================================= ***************************************** CONSTANTS ========================================= ***************************************** */ #define MODULEI 0 #define CLASSI 1 #define LINKI 2 #define SLOTI 3 #define TSLOTI 4 #define OSLOTI 5 #define HANDLERI 6 #define OHANDLERI 7 #define SAVE_ITEMS 8 /* ========================================= ***************************************** MACROS AND TYPES ========================================= ***************************************** */ #define ClassPrefix() ConstructPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem) #define ClassLinkPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,2) #define SlotPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,3) #define TemplateSlotPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,4) #define OrderedSlotPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,5) #define HandlerPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,6) #define OrderedHandlerPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,7) #define SlotNamePrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,8) #define SlotNameHashPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,9) #define ClassHashPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,10) #define ClassIDPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,11) #define MaxClassIDPrefix() ArbitraryPrefix(ObjectCompilerData(theEnv)->ObjectCodeItem,12) typedef struct { unsigned long classCount; unsigned short currentPartition; unsigned short slotCount; unsigned int maxIndices; } MARK_INFO; typedef union { struct { unsigned thePartition : 16; unsigned theOffset : 16; } theLocation; unsigned long theLong; } PACKED_LOCATION_INFO; /***************************************/ /* LOCAL INTERNAL FUNCTION DEFINITIONS */ /***************************************/ static void ReadyObjectsForCode(Environment *); static void MarkDefclassAndSlots(Environment *,ConstructHeader *,void *); static void PrintSlotNameReference(Environment *,FILE *,SLOT_NAME *,unsigned int,unsigned int); static void InitObjectsCode(Environment *,FILE *,unsigned int,unsigned int); static bool ObjectsToCode(Environment *,const char *,const char *,char *,unsigned int, FILE *,unsigned int,unsigned int); static bool ClassIDMapToCode(Environment *,const char *,const char *,char *,unsigned int, FILE *,unsigned int,unsigned int,unsigned int *); static bool ClassHashTableToCode(Environment *,const char *,const char *,char *,unsigned int, FILE *,unsigned int,unsigned int,unsigned int *); static bool SlotNameHashTableToCode(Environment *,const char *,const char *,char *,unsigned int, FILE *,unsigned int,unsigned int,unsigned int *); static bool SlotNameEntriesToCode(Environment *,const char *,const char *,char *,unsigned int, FILE *,unsigned int,unsigned int,unsigned int *); static void CloseObjectFiles(Environment *,FILE *[SAVE_ITEMS],bool [SAVE_ITEMS], struct CodeGeneratorFile [SAVE_ITEMS],unsigned int); static void DefclassModuleToCode(Environment *,FILE *,Defmodule *,unsigned int,unsigned int); static void SingleDefclassToCode(Environment *,FILE *,unsigned int,unsigned int,Defclass *,unsigned int, unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int, unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int); static bool InheritanceLinksToCode(Environment *,FILE **,const char *,const char *,char *, unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); static bool SlotsToCode(Environment *,FILE **,const char *,const char *,char *,unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); static bool TemplateSlotsToCode(Environment *,FILE **,const char *,const char *,char *, unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); static bool OrderedSlotsToCode(Environment *,FILE **,const char *,const char *,char *, unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); static bool HandlersToCode(Environment *,FILE **,const char *,const char *,char *, unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); static bool OrderedHandlersToCode(Environment *,FILE **,const char *,const char *,char *, unsigned int,unsigned int,FILE *, unsigned int *,unsigned int,Defclass *,unsigned int *, unsigned int *,bool *,struct CodeGeneratorFile *); /* ========================================= ***************************************** EXTERNALLY VISIBLE FUNCTIONS ========================================= ***************************************** */ /*************************************************** NAME : SetupObjectsCompiler DESCRIPTION : Initializes the construct compiler item for defclasses & handlers INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : Code generator item initialized NOTES : None ***************************************************/ void SetupObjectsCompiler( Environment *theEnv) { AllocateEnvironmentData(theEnv,OBJECT_COMPILER_DATA,sizeof(struct objectCompilerData),NULL); ObjectCompilerData(theEnv)->ObjectCodeItem = AddCodeGeneratorItem(theEnv,"objects",0,ReadyObjectsForCode, InitObjectsCode,ObjectsToCode,13); } /********************************************************* NAME : PrintClassReference DESCRIPTION : Writes out a reference to the class array INPUTS : 1) Output file pointer 2) Class address 3) Construct set image id 4) The maximum number of indices allowed in an array RETURNS : Nothing useful SIDE EFFECTS : Writes out class array reference to file NOTES : None *********************************************************/ void PrintClassReference( Environment *theEnv, FILE *fp, Defclass *cls, unsigned int imageID, unsigned int maxIndices) { if (cls == NULL) fprintf(fp,"NULL"); else fprintf(fp,"&%s%u_%lu[%lu]", ClassPrefix(), imageID, ((cls->header.bsaveID / maxIndices) + 1), (cls->header.bsaveID % maxIndices)); } /**************************************************** NAME : DefclassCModuleReference DESCRIPTION : Prints out a reference to a defclass module INPUTS : 1) The output file 2) The id of the module item 3) The id of the image 4) The maximum number of elements allowed in an array RETURNS : Nothing useful SIDE EFFECTS : Defclass module reference printed NOTES : None ****************************************************/ void DefclassCModuleReference( Environment *theEnv, FILE *theFile, unsigned long count, unsigned int imageID, unsigned int maxIndices) { fprintf(theFile,"MIHS &%s%u_%lu[%lu]", ModulePrefix(ObjectCompilerData(theEnv)->ObjectCodeItem), imageID, (count / maxIndices) + 1, (count % maxIndices)); } /* ========================================= ***************************************** INTERNALLY VISIBLE FUNCTIONS ========================================= ***************************************** */ /******************************************************* NAME : ReadyObjectsForCode DESCRIPTION : Sets index of classes and slot name entries for use in compiled expressions INPUTS : None RETURNS : Nothing useful SIDE EFFECTS : BsaveIndices set NOTES : None *******************************************************/ static void ReadyObjectsForCode( Environment *theEnv) { MARK_INFO markInfo; unsigned long i; int j; SLOT_NAME *snp; markInfo.classCount = 0L; markInfo.currentPartition = 1; markInfo.slotCount = 0; /* ===================================== Gets the value of MaxIndices directly from the global in CONSCOMP.C ===================================== */ markInfo.maxIndices = ConstructCompilerData(theEnv)->MaxIndices; DoForAllConstructs(theEnv,MarkDefclassAndSlots,DefclassData(theEnv)->DefclassModuleIndex, false,&markInfo); i = 0L; for (j = 0 ; j < SLOT_NAME_TABLE_HASH_SIZE ; j++) for (snp = DefclassData(theEnv)->SlotNameTable[j] ; snp != NULL ; snp = snp->nxt) snp->bsaveIndex = i++; } /************************************************************ NAME : MarkDefclassAndSlots DESCRIPTION : Sets the bsave indices of the classes for use in printing references to them later. Also, the partitions and offsets are predetermined for every slot and packed into a single long (the slot bsave index) for use in printing references to them later INPUTS : 1) The defclass 2) A buffer containing the info: a) Total number of classes counted so far b) The current partition # for slots c) The current offset in that partition d) The max # of elements in any array RETURNS : Nothing useful SIDE EFFECTS : Bsave indices of classes and slots set NOTES : The template slots are written at the same time as the real slots - thus the references must be predetermined ************************************************************/ static void MarkDefclassAndSlots( Environment *theEnv, ConstructHeader *vTheDefclass, void *vTheBuffer) { Defclass *theDefclass = (Defclass *) vTheDefclass; MARK_INFO *markInfo = (MARK_INFO *) vTheBuffer; long i; PACKED_LOCATION_INFO theLocationInfo; #if MAC_XCD #pragma unused(theEnv) #endif theDefclass->header.bsaveID = markInfo->classCount++; for (i = 0 ; i < theDefclass->slotCount ; i++) { theLocationInfo.theLocation.thePartition = markInfo->currentPartition; theLocationInfo.theLocation.theOffset = markInfo->slotCount; theDefclass->slots[i].bsaveIndex = theLocationInfo.theLong; markInfo->slotCount++; if (markInfo->slotCount >= markInfo->maxIndices) { markInfo->currentPartition++; markInfo->slotCount = 0; } } } /************************************************************* NAME : PrintSlotNameReference DESCRIPTION : Writes out a reference to the slot name array INPUTS : 1) Output file pointer 2) Slot name address 3) Construct set image id 4) The maximum number of indices allowed in an array RETURNS : Nothing useful SIDE EFFECTS : Writes out slot name array reference to file NOTES : None *************************************************************/ static void PrintSlotNameReference( Environment *theEnv, FILE *fp, SLOT_NAME *snp, unsigned int imageID, unsigned int maxIndices) { if (snp == NULL) fprintf(fp,"NULL"); else fprintf(fp,"&%s%u_%lu[%lu]", SlotNamePrefix(), imageID, ((snp->bsaveIndex / maxIndices) + 1), (snp->bsaveIndex % maxIndices)); } /******************************************************* NAME : InitObjectsCode DESCRIPTION : Writes out initialization code for generic functions INPUTS : 1) The initialization code file pointer 2) The construct set image id 3) The max number of indices allowed in an array for this construct set RETURNS : Nothing useful SIDE EFFECTS : Writes out initialization code NOTES : None *******************************************************/ static void InitObjectsCode( Environment *theEnv, FILE *initFP, unsigned int imageID, unsigned int maxIndices) { #if MAC_XCD #pragma unused(maxIndices) #endif fprintf(initFP," ObjectsRunTimeInitialize(theEnv,%s%u_1,%s%u_1,%s%u_1,%s%u);\n", ClassHashPrefix(),imageID,SlotNameHashPrefix(),imageID, ClassIDPrefix(),imageID,MaxClassIDPrefix(),imageID); } /************************************************************* NAME : ObjectsToCode DESCRIPTION : Writes out static array code for classes, message-handlers, and associated structures 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 : False on errors, True if object system structures written SIDE EFFECTS : Code written to files NOTES : None *************************************************************/ static bool ObjectsToCode( 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; Defclass *theDefclass; int i; unsigned int moduleCount = 0; unsigned int itemArrayCounts[SAVE_ITEMS]; unsigned int itemArrayVersions[SAVE_ITEMS]; FILE *itemFiles[SAVE_ITEMS]; bool 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; itemCodeFiles[i].pathName = pathName; itemCodeFiles[i].fileNameBuffer = fileNameBuffer; } fprintf(headerFP,"#include \"classcom.h\"\n"); fprintf(headerFP,"#include \"classini.h\"\n"); if (ClassIDMapToCode(theEnv,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,maxIndices,&fileCount) == false) return false; if (ClassHashTableToCode(theEnv,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,maxIndices,&fileCount) == false) return false; if (SlotNameHashTableToCode(theEnv,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,maxIndices,&fileCount) == false) return false; if (SlotNameEntriesToCode(theEnv,fileName,pathName,fileNameBuffer,fileID,headerFP,imageID,maxIndices,&fileCount) == false) return false; /* ============================================================= Loop through all the modules and all the defclasses writing their C code representation to the file as they are traversed ============================================================= */ theModule = GetNextDefmodule(theEnv,NULL); while (theModule != NULL) { SetCurrentModule(theEnv,theModule); itemFiles[MODULEI] = OpenFileIfNeeded(theEnv,itemFiles[MODULEI],fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount, itemArrayVersions[MODULEI],headerFP, "DEFCLASS_MODULE",ModulePrefix(ObjectCompilerData(theEnv)->ObjectCodeItem), itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]); if (itemFiles[MODULEI] == NULL) goto ObjectCodeError; DefclassModuleToCode(theEnv,itemFiles[MODULEI],theModule,imageID,maxIndices); itemFiles[MODULEI] = CloseFileIfNeeded(theEnv,itemFiles[MODULEI],&itemArrayCounts[MODULEI], &itemArrayVersions[MODULEI],maxIndices, &itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]); for (theDefclass = GetNextDefclass(theEnv,NULL) ; theDefclass != NULL ; theDefclass = GetNextDefclass(theEnv,theDefclass)) { itemFiles[CLASSI] = OpenFileIfNeeded(theEnv,itemFiles[CLASSI],fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount, itemArrayVersions[CLASSI],headerFP, "Defclass",ClassPrefix(), itemReopenFlags[CLASSI],&itemCodeFiles[CLASSI]); if (itemFiles[CLASSI] == NULL) goto ObjectCodeError; SingleDefclassToCode(theEnv,itemFiles[CLASSI],imageID,maxIndices, theDefclass,moduleCount, itemArrayVersions[LINKI],itemArrayCounts[LINKI], itemArrayVersions[SLOTI],itemArrayCounts[SLOTI], itemArrayVersions[TSLOTI],itemArrayCounts[TSLOTI], itemArrayVersions[OSLOTI],itemArrayCounts[OSLOTI], itemArrayVersions[HANDLERI],itemArrayCounts[HANDLERI], itemArrayVersions[OHANDLERI],itemArrayCounts[OHANDLERI]); itemArrayCounts[CLASSI]++; itemFiles[CLASSI] = CloseFileIfNeeded(theEnv,itemFiles[CLASSI],&itemArrayCounts[CLASSI], &itemArrayVersions[CLASSI],maxIndices, &itemReopenFlags[CLASSI],&itemCodeFiles[CLASSI]); if (InheritanceLinksToCode(theEnv,&itemFiles[LINKI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass, &itemArrayVersions[LINKI],&itemArrayCounts[LINKI], &itemReopenFlags[LINKI],&itemCodeFiles[LINKI]) == false) goto ObjectCodeError; if (SlotsToCode(theEnv,&itemFiles[SLOTI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass, &itemArrayVersions[SLOTI],&itemArrayCounts[SLOTI], &itemReopenFlags[SLOTI],&itemCodeFiles[SLOTI]) == false) goto ObjectCodeError; if (TemplateSlotsToCode(theEnv,&itemFiles[TSLOTI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass, &itemArrayVersions[TSLOTI],&itemArrayCounts[TSLOTI], &itemReopenFlags[TSLOTI],&itemCodeFiles[TSLOTI]) == false) goto ObjectCodeError; if (OrderedSlotsToCode(theEnv,&itemFiles[OSLOTI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass, &itemArrayVersions[OSLOTI],&itemArrayCounts[OSLOTI], &itemReopenFlags[OSLOTI],&itemCodeFiles[OSLOTI]) == false) goto ObjectCodeError; if (HandlersToCode(theEnv,&itemFiles[HANDLERI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass,moduleCount, &itemArrayVersions[HANDLERI],&itemArrayCounts[HANDLERI], &itemReopenFlags[HANDLERI],&itemCodeFiles[HANDLERI]) == false) goto ObjectCodeError; if (OrderedHandlersToCode(theEnv,&itemFiles[OHANDLERI],fileName,pathName,fileNameBuffer,fileID,imageID, headerFP,&fileCount,maxIndices,theDefclass, &itemArrayVersions[OHANDLERI],&itemArrayCounts[OHANDLERI], &itemReopenFlags[OHANDLERI],&itemCodeFiles[OHANDLERI]) == false) goto ObjectCodeError; } theModule = GetNextDefmodule(theEnv,theModule); moduleCount++; itemArrayCounts[MODULEI]++; } CloseObjectFiles(theEnv,itemFiles,itemReopenFlags,itemCodeFiles,maxIndices); return true; ObjectCodeError: CloseObjectFiles(theEnv,itemFiles,itemReopenFlags,itemCodeFiles,maxIndices); return false; } /************************************************************ NAME : ClassIDMapToCode DESCRIPTION : Writes out class id map INPUTS : 1) Header file pointer 2) Output file pointer 3) The construct set image id 4) The max # of allowed indices 5) Caller's file count buffer RETURNS : True if all OK, false otherwise SIDE EFFECTS : Class ID Map and Max Indices Written NOTES : None ***********************************************************/ static bool ClassIDMapToCode( Environment *theEnv, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, FILE *headerFP, unsigned int imageID, unsigned int maxIndices, unsigned int *fileCount) { FILE *classIDMapFile = NULL; unsigned int classIDMapArrayCount; unsigned int classIDMapArrayVersion = 1; classIDMapFile = OpenFileIfNeeded(theEnv,classIDMapFile,fileName,pathName,fileNameBuffer,fileID,imageID,fileCount, classIDMapArrayVersion,headerFP, "Defclass *",ClassIDPrefix(),false,NULL); if (classIDMapFile == NULL) return false; for (classIDMapArrayCount = 0 ; classIDMapArrayCount < DefclassData(theEnv)->MaxClassID ; classIDMapArrayCount++) { if (classIDMapArrayCount > 0) fprintf(classIDMapFile,",\n"); PrintClassReference(theEnv,classIDMapFile,DefclassData(theEnv)->ClassIDMap[classIDMapArrayCount], imageID,maxIndices); } fprintf(classIDMapFile,"};\n\n"); fprintf(classIDMapFile,"unsigned %s%d = %u;\n", MaxClassIDPrefix(),imageID,(unsigned) DefclassData(theEnv)->MaxClassID); fprintf(headerFP,"extern unsigned %s%d;\n",MaxClassIDPrefix(),imageID); GenClose(theEnv,classIDMapFile); return true; } /************************************************************ NAME : ClassHashTableToCode DESCRIPTION : Writes out class hash table INPUTS : 1) Header file pointer 2) Output file pointer 3) The construct set image id 4) The max # of allowed indices 5) Caller's file count buffer RETURNS : True if all OK, false otherwise SIDE EFFECTS : Class Hash Table Written NOTES : None ***********************************************************/ static bool ClassHashTableToCode( Environment *theEnv, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, FILE *headerFP, unsigned int imageID, unsigned int maxIndices, unsigned int *fileCount) { FILE *classHashFile = NULL; unsigned int classHashArrayCount, classHashArrayVersion = 1; classHashFile = OpenFileIfNeeded(theEnv,classHashFile,fileName,pathName,fileNameBuffer,fileID,imageID,fileCount, classHashArrayVersion,headerFP, "Defclass *",ClassHashPrefix(),false,NULL); if (classHashFile == NULL) return false; for (classHashArrayCount = 0 ; classHashArrayCount < CLASS_TABLE_HASH_SIZE ; classHashArrayCount++) { if (classHashArrayCount > 0) fprintf(classHashFile,",\n"); PrintClassReference(theEnv,classHashFile,DefclassData(theEnv)->ClassTable[classHashArrayCount], imageID,maxIndices); } CloseFileIfNeeded(theEnv,classHashFile,&classHashArrayCount, &classHashArrayVersion,classHashArrayCount,NULL,NULL); return true; } /************************************************************ NAME : SlotNameHashTableToCode DESCRIPTION : Writes out slot name entry hash table INPUTS : 1) Header file pointer 2) Output file pointer 3) The construct set image id 4) The max # of allowed indices 5) Caller's version number buffer RETURNS : True if all OK, false otherwise SIDE EFFECTS : Slot Name Hash Table Written NOTES : None ***********************************************************/ static bool SlotNameHashTableToCode( Environment *theEnv, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, FILE *headerFP, unsigned int imageID, unsigned int maxIndices, unsigned int *fileCount) { FILE *slotNameHashFile = NULL; unsigned int slotNameHashArrayCount, slotNameHashArrayVersion = 1; slotNameHashFile = OpenFileIfNeeded(theEnv,slotNameHashFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, slotNameHashArrayVersion,headerFP, "SLOT_NAME *",SlotNameHashPrefix(),false,NULL); if (slotNameHashFile == NULL) return false; for (slotNameHashArrayCount = 0 ; slotNameHashArrayCount < SLOT_NAME_TABLE_HASH_SIZE ; slotNameHashArrayCount++) { if (slotNameHashArrayCount > 0) fprintf(slotNameHashFile,",\n"); PrintSlotNameReference(theEnv,slotNameHashFile,DefclassData(theEnv)->SlotNameTable[slotNameHashArrayCount], imageID,maxIndices); } CloseFileIfNeeded(theEnv,slotNameHashFile,&slotNameHashArrayCount, &slotNameHashArrayVersion,slotNameHashArrayCount, NULL,NULL); return true; } /************************************************************ NAME : SlotNameEntriesToCode DESCRIPTION : Writes out slot name entries INPUTS : 1) Header file pointer 2) Output file pointer 3) The construct set image id 4) The max # of allowed indices 5) Caller's version number buffer RETURNS : True if all OK, false otherwise SIDE EFFECTS : Slot name entries Written NOTES : None ***********************************************************/ static bool SlotNameEntriesToCode( Environment *theEnv, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, FILE *headerFP, unsigned int imageID, unsigned int maxIndices, unsigned int *fileCount) { FILE *slotNameFile = NULL; unsigned int slotNameArrayCount = 0, slotNameArrayVersion = 1; SLOT_NAME *snp; unsigned i; for (i = 0 ; i < SLOT_NAME_TABLE_HASH_SIZE ; i++) { for (snp = DefclassData(theEnv)->SlotNameTable[i] ; snp != NULL ; snp = snp->nxt) { slotNameFile = OpenFileIfNeeded(theEnv,slotNameFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, slotNameArrayVersion,headerFP, "SLOT_NAME",SlotNamePrefix(),false,NULL); if (slotNameFile == NULL) return false; fprintf(slotNameFile,"{ %u,1,%d,",snp->hashTableIndex,snp->id); PrintSymbolReference(theEnv,slotNameFile,snp->name); fprintf(slotNameFile,","); PrintSymbolReference(theEnv,slotNameFile,snp->putHandlerName); fprintf(slotNameFile,","); PrintSlotNameReference(theEnv,slotNameFile,snp->nxt,imageID,maxIndices); fprintf(slotNameFile,",0L }"); slotNameArrayCount++; slotNameFile = CloseFileIfNeeded(theEnv,slotNameFile,&slotNameArrayCount, &slotNameArrayVersion,maxIndices,NULL,NULL); } } if (slotNameFile != NULL) CloseFileIfNeeded(theEnv,slotNameFile,&slotNameArrayCount, &slotNameArrayVersion,slotNameArrayCount,NULL,NULL); return true; } /****************************************************** NAME : CloseObjectFiles DESCRIPTION : Closes construct compiler files for defclass 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 CloseObjectFiles( Environment *theEnv, FILE *itemFiles[SAVE_ITEMS], bool itemReopenFlags[SAVE_ITEMS], struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS], unsigned int maxIndices) { unsigned int count = maxIndices; unsigned int arrayVersion = 0; int i; for (i = 0 ; i < SAVE_ITEMS ; i++) { count = maxIndices; itemFiles[i] = CloseFileIfNeeded(theEnv,itemFiles[i],&count,&arrayVersion, maxIndices,&itemReopenFlags[i], &itemCodeFiles[i]); } } /*************************************************** NAME : DefclassModuleToCode DESCRIPTION : Writes out the C values for a defclass module item INPUTS : 1) The output file 2) The module for the defclasses 3) The compile image id 4) The maximum number of elements in an array RETURNS : Nothing useful SIDE EFFECTS : Defclass module item written NOTES : None ***************************************************/ static void DefclassModuleToCode( Environment *theEnv, FILE *theFile, Defmodule *theModule, unsigned int imageID, unsigned int maxIndices) { fprintf(theFile,"{"); ConstructModuleToCode(theEnv,theFile,theModule,imageID,maxIndices, DefclassData(theEnv)->DefclassModuleIndex,ClassPrefix()); fprintf(theFile,"}"); } /**************************************************************** NAME : SingleDefclassToCode DESCRIPTION : Writes out a single defclass's data to the file INPUTS : 1) The output file 2) The compile image id 3) The maximum number of elements in an array 4) The defclass 5) The module index 6) The partition holding the defclass inheritance links 7) The relative index of the inheritance links in the partition 8) The partition holding the defclass slots 9) The relative index of the slots in the partition 10) The partition holding the defclass template slots 11) The relative index of the template slots in the partition 12) The partition holding the defclass ordered slot map 13) The relative index of the ordered slot map in the partition 14) The partition holding the defclass message-handlers 15) The relative index of the message-handlers in the partition 16) The partition holding the defclass ordered handler map 17) The relative index of the ordered handler map in the partition RETURNS : Nothing useful SIDE EFFECTS : Defclass data written NOTES : None ***************************************************************/ static void SingleDefclassToCode( Environment *theEnv, FILE *theFile, unsigned int imageID, unsigned int maxIndices, Defclass *theDefclass, unsigned int moduleCount, unsigned int classLinkArrayVersion, unsigned int classLinkArrayCount, unsigned int slotArrayVersion, unsigned int slotArrayCount, unsigned int templateSlotArrayVersion, unsigned int templateSlotArrayCount, unsigned int orderedSlotArrayVersion, unsigned int orderedSlotArrayCount, unsigned int handlerArrayVersion, unsigned int handlerArrayCount, unsigned int orderedHandlerArrayVersion, unsigned int orderedHandlerArrayCount) { /* ================== Defclass Header ================== */ fprintf(theFile,"{"); ConstructHeaderToCode(theEnv,theFile,&theDefclass->header,imageID,maxIndices,moduleCount, ModulePrefix(ObjectCompilerData(theEnv)->ObjectCodeItem),ClassPrefix()); /* ========================= Defclass specific data ========================= */ fprintf(theFile,",1,%u,%u,%u,0,0,%u,0,%u,\n ", theDefclass->system,theDefclass->abstract, theDefclass->reactive,(unsigned) theDefclass->id, theDefclass->hashTableIndex); if (theDefclass->directSuperclasses.classCount > 0) fprintf(theFile,"{ %lu,&%s%d_%d[%d] },", theDefclass->directSuperclasses.classCount, ClassLinkPrefix(), imageID,classLinkArrayVersion,classLinkArrayCount); else fprintf(theFile,"{ 0,NULL },"); classLinkArrayCount += theDefclass->directSuperclasses.classCount; if (theDefclass->directSubclasses.classCount > 0) fprintf(theFile,"{ %lu,&%s%d_%d[%d] },", theDefclass->directSubclasses.classCount, ClassLinkPrefix(), imageID,classLinkArrayVersion,classLinkArrayCount); else fprintf(theFile,"{ 0,NULL },"); classLinkArrayCount += theDefclass->directSubclasses.classCount; if (theDefclass->allSuperclasses.classCount > 0) fprintf(theFile,"{ %lu,&%s%d_%d[%d] },", theDefclass->allSuperclasses.classCount, ClassLinkPrefix(), imageID,classLinkArrayVersion,classLinkArrayCount); else fprintf(theFile,"{ 0,NULL },\n "); if (theDefclass->slots != NULL) fprintf(theFile,"&%s%d_%d[%d],", SlotPrefix(),imageID, slotArrayVersion,slotArrayCount); else fprintf(theFile,"NULL,"); if (theDefclass->instanceTemplate != NULL) fprintf(theFile,"&%s%d_%d[%d],", TemplateSlotPrefix(),imageID, templateSlotArrayVersion,templateSlotArrayCount); else fprintf(theFile,"NULL,"); if (theDefclass->slotNameMap != NULL) fprintf(theFile,"&%s%d_%d[%d],", OrderedSlotPrefix(),imageID, orderedSlotArrayVersion,orderedSlotArrayCount); else fprintf(theFile,"NULL,"); fprintf(theFile,"%u,%u,%u,%u,NULL,NULL,\n ", theDefclass->slotCount,theDefclass->localInstanceSlotCount, theDefclass->instanceSlotCount,theDefclass->maxSlotNameID); if (theDefclass->handlers != NULL) fprintf(theFile,"&%s%d_%d[%d],", HandlerPrefix(),imageID, handlerArrayVersion,handlerArrayCount); else fprintf(theFile,"NULL,"); if (theDefclass->handlerOrderMap != NULL) fprintf(theFile,"&%s%d_%d[%d],", OrderedHandlerPrefix(),imageID, orderedHandlerArrayVersion,orderedHandlerArrayCount); else fprintf(theFile,"NULL,"); fprintf(theFile,"%u,",theDefclass->handlerCount); PrintClassReference(theEnv,theFile,theDefclass->nxtHash,imageID,maxIndices); fprintf(theFile,","); PrintBitMapReference(theEnv,theFile,theDefclass->scopeMap); #if DEFRULE_CONSTRUCT fprintf(theFile,","); ClassAlphaLinkReference(theEnv,theDefclass->relevant_terminal_alpha_nodes,theFile,imageID,maxIndices); #endif fprintf(theFile,",\"\""); fprintf(theFile,"}"); } /*********************************************************** NAME : InheritanceLinksToCode DESCRIPTION : Prints out superclass/subclass inheritance links - all links for a particular class are guaranteed to be in the same array partition INPUTS : 1) A buffer for the inheritance links file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the links partition # 10) A buffer holding the links relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, false otherwise SIDE EFFECTS : Inheritance links written NOTES : None ***********************************************************/ static bool InheritanceLinksToCode( Environment *theEnv, FILE **classLinkFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int *classLinkArrayVersion, unsigned int *classLinkArrayCount, bool *reopenClassLinkFile, struct CodeGeneratorFile *classLinkCodeFile) { unsigned long i; unsigned long inheritanceLinkCount; bool linkPrinted = false; inheritanceLinkCount = theDefclass->directSuperclasses.classCount + theDefclass->directSubclasses.classCount + theDefclass->allSuperclasses.classCount; if (inheritanceLinkCount == 0) return true; *classLinkFile = OpenFileIfNeeded(theEnv,*classLinkFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *classLinkArrayVersion,headerFP, "Defclass *",ClassLinkPrefix(), *reopenClassLinkFile,classLinkCodeFile); if (*classLinkFile == NULL) return false; for (i = 0 ; i < theDefclass->directSuperclasses.classCount ; i++) { if (linkPrinted) fprintf(*classLinkFile,","); PrintClassReference(theEnv,*classLinkFile, theDefclass->directSuperclasses.classArray[i], imageID,maxIndices); linkPrinted = true; } for (i = 0 ; i < theDefclass->directSubclasses.classCount ; i++) { if (linkPrinted) fprintf(*classLinkFile,","); PrintClassReference(theEnv,*classLinkFile, theDefclass->directSubclasses.classArray[i], imageID,maxIndices); linkPrinted = true; } for (i = 0 ; i < theDefclass->allSuperclasses.classCount ; i++) { if (linkPrinted) fprintf(*classLinkFile,","); PrintClassReference(theEnv,*classLinkFile, theDefclass->allSuperclasses.classArray[i], imageID,maxIndices); linkPrinted = true; } *classLinkArrayCount += inheritanceLinkCount; *classLinkFile = CloseFileIfNeeded(theEnv,*classLinkFile,classLinkArrayCount, classLinkArrayVersion,maxIndices, reopenClassLinkFile,classLinkCodeFile); return true; } /*********************************************************** NAME : SlotsToCode DESCRIPTION : Prints out slots - all slots for a particular class are guaranteed to be in the same array partition INPUTS : 1) A buffer for the slots file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the slots partition # 10) A buffer holding the slots relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, FALSE otherwise SIDE EFFECTS : Slots written NOTES : None ***********************************************************/ static bool SlotsToCode( Environment *theEnv, FILE **slotFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int *slotArrayVersion, unsigned int *slotArrayCount, bool *reopenSlotFile, struct CodeGeneratorFile *slotCodeFile) { long i; SlotDescriptor *sd; Expression *tmpexp; PACKED_LOCATION_INFO theLocationInfo; if (theDefclass->slotCount == 0) return true; *slotFile = OpenFileIfNeeded(theEnv,*slotFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *slotArrayVersion,headerFP, "SlotDescriptor",SlotPrefix(), *reopenSlotFile,slotCodeFile); if (*slotFile == NULL) return false; for (i = 0 ; i < theDefclass->slotCount ; i++) { sd = &theDefclass->slots[i]; if (i > 0) fprintf(*slotFile,",\n"); fprintf(*slotFile,"{ %u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,", sd->shared,sd->multiple, sd->composite,sd->noInherit, sd->noWrite,sd->initializeOnly, sd->dynamicDefault,sd->defaultSpecified, sd->noDefault,sd->reactive, sd->publicVisibility,sd->createReadAccessor, sd->createWriteAccessor,sd->overrideMessageSpecified); PrintClassReference(theEnv,*slotFile,sd->cls,imageID,maxIndices); fprintf(*slotFile,","); PrintSlotNameReference(theEnv,*slotFile,sd->slotName,imageID,maxIndices); fprintf(*slotFile,",\n "); PrintSymbolReference(theEnv,*slotFile,sd->overrideMessage); if (sd->defaultValue != NULL) { fprintf(*slotFile,",(void *) "); if (sd->dynamicDefault) ExpressionToCode(theEnv,*slotFile,(Expression *) sd->defaultValue); else { tmpexp = ConvertValueToExpression(theEnv,(UDFValue *) sd->defaultValue); ExpressionToCode(theEnv,*slotFile,tmpexp); ReturnExpression(theEnv,tmpexp); } } else fprintf(*slotFile,",NULL"); fprintf(*slotFile,","); PrintConstraintReference(theEnv,*slotFile,sd->constraint,imageID,maxIndices); fprintf(*slotFile,",0,0L,"); if (sd->shared) { theLocationInfo.theLong = sd->sharedValue.desc->bsaveIndex; fprintf(*slotFile,"{ &%s%d_%u[%u],0,0,0,{ NULL } } }", SlotPrefix(),imageID, theLocationInfo.theLocation.thePartition, theLocationInfo.theLocation.theOffset); } else fprintf(*slotFile,"{ NULL,0,0,0, { NULL } } }"); } *slotArrayCount += theDefclass->slotCount; *slotFile = CloseFileIfNeeded(theEnv,*slotFile,slotArrayCount, slotArrayVersion,maxIndices, reopenSlotFile,slotCodeFile); return true; } /************************************************************* NAME : TemplateSlotsToCode DESCRIPTION : Prints out instance template - the entire instance slot template for a particular class is guaranteed to be in the same array partition INPUTS : 1) A buffer for the template file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the template partition # 10) A buffer holding the template relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, false otherwise SIDE EFFECTS : Templates written NOTES : None *************************************************************/ static bool TemplateSlotsToCode( Environment *theEnv, FILE **templateSlotFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int *templateSlotArrayVersion, unsigned int *templateSlotArrayCount, bool *reopenTemplateSlotFile, struct CodeGeneratorFile *templateSlotCodeFile) { unsigned long i; SlotDescriptor *sd; PACKED_LOCATION_INFO theLocationInfo; if (theDefclass->instanceSlotCount == 0) return true; *templateSlotFile = OpenFileIfNeeded(theEnv,*templateSlotFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *templateSlotArrayVersion,headerFP, "SlotDescriptor *",TemplateSlotPrefix(), *reopenTemplateSlotFile,templateSlotCodeFile); if (*templateSlotFile == NULL) return false; for (i = 0 ; i < theDefclass->instanceSlotCount ; i++) { sd = theDefclass->instanceTemplate[i]; if (i > 0) fprintf(*templateSlotFile,","); theLocationInfo.theLong = sd->bsaveIndex; fprintf(*templateSlotFile,"&%s%d_%u[%u]", SlotPrefix(),imageID, theLocationInfo.theLocation.thePartition, theLocationInfo.theLocation.theOffset); } *templateSlotArrayCount += theDefclass->instanceSlotCount; *templateSlotFile = CloseFileIfNeeded(theEnv,*templateSlotFile,templateSlotArrayCount, templateSlotArrayVersion,maxIndices, reopenTemplateSlotFile,templateSlotCodeFile); return true; } /************************************************************* NAME : OrderedSlotsToCode DESCRIPTION : Prints out slot name map - the entire slot name map for a particular class is guaranteed to be in the same array partition INPUTS : 1) A buffer for the slot map file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the slot map partition # 10) A buffer holding the slot map relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, false otherwise SIDE EFFECTS : Slot maps written NOTES : None *************************************************************/ static bool OrderedSlotsToCode( Environment *theEnv, FILE **orderedSlotFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int *orderedSlotArrayVersion, unsigned int *orderedSlotArrayCount, bool *reopenOrderedSlotFile, struct CodeGeneratorFile *orderedSlotCodeFile) { long i; if (theDefclass->instanceSlotCount == 0) return true; *orderedSlotFile = OpenFileIfNeeded(theEnv,*orderedSlotFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *orderedSlotArrayVersion,headerFP, "unsigned",OrderedSlotPrefix(), *reopenOrderedSlotFile,orderedSlotCodeFile); if (*orderedSlotFile == NULL) return false; for (i = 0 ; i <= theDefclass->maxSlotNameID ; i++) { if (i > 0) fprintf(*orderedSlotFile,","); fprintf(*orderedSlotFile,"%u",theDefclass->slotNameMap[i]); } *orderedSlotArrayCount += theDefclass->maxSlotNameID + 1; *orderedSlotFile = CloseFileIfNeeded(theEnv,*orderedSlotFile,orderedSlotArrayCount, orderedSlotArrayVersion,maxIndices, reopenOrderedSlotFile,orderedSlotCodeFile); return true; } /************************************************************* NAME : HandlersToCode DESCRIPTION : Prints out message-handlers - all message-handlers for a particular class are guaranteed to be in the same array partition INPUTS : 1) A buffer for the handler file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the handler partition # 10) A buffer holding the handler relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, false otherwise SIDE EFFECTS : Handlers written NOTES : None *************************************************************/ static bool HandlersToCode( Environment *theEnv, FILE **handlerFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int moduleCount, unsigned int *handlerArrayVersion, unsigned int *handlerArrayCount, bool *reopenHandlerFile, struct CodeGeneratorFile *handlerCodeFile) { unsigned int i; DefmessageHandler *hnd; if (theDefclass->handlerCount == 0) return true; *handlerFile = OpenFileIfNeeded(theEnv,*handlerFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *handlerArrayVersion,headerFP, "DefmessageHandler",HandlerPrefix(),*reopenHandlerFile, handlerCodeFile); if (*handlerFile == NULL) return false; for (i = 0 ; i < theDefclass->handlerCount ; i++) { if (i > 0) fprintf(*handlerFile,",\n"); hnd = &theDefclass->handlers[i]; fprintf(*handlerFile,"{"); ConstructHeaderToCode(theEnv,*handlerFile,&hnd->header,imageID,maxIndices,moduleCount, ModulePrefix(ObjectCompilerData(theEnv)->ObjectCodeItem),HandlerPrefix()); fprintf(*handlerFile,",%u,%u,0,0,0,",hnd->system,hnd->type); PrintClassReference(theEnv,*handlerFile,hnd->cls,imageID,maxIndices); fprintf(*handlerFile,",%hu,%hu,%hu,",hnd->minParams,hnd->maxParams,hnd->localVarCount); ExpressionToCode(theEnv,*handlerFile,hnd->actions); fprintf(*handlerFile,"}"); } *handlerArrayCount += theDefclass->handlerCount; *handlerFile = CloseFileIfNeeded(theEnv,*handlerFile,handlerArrayCount, handlerArrayVersion,maxIndices, reopenHandlerFile,handlerCodeFile); return true; } /**************************************************************** NAME : OrderedHandlersToCode DESCRIPTION : Prints out handler map - the entire handler map for a particular class is guaranteed to be in the same array partition INPUTS : 1) A buffer for the handler map file 2) The base image name 3) The id for this type of data 4) The base image id 5) The general header file 6) A buffer for the version number of the file for this type of data 7) The maximum # of elements in any array 8) A pointer to the class 9) A buffer holding the handler map partition # 10) A buffer holding the handler map relative index in the partition 11) A buffer for a flag indicating if the buffer file can be reopened later 12) A pointer to the file info for this data if the last file needs to be reopened for termination RETURNS : True if all OK, false otherwise SIDE EFFECTS : Handler maps written NOTES : None ****************************************************************/ static bool OrderedHandlersToCode( Environment *theEnv, FILE **orderedHandlerFile, const char *fileName, const char *pathName, char *fileNameBuffer, unsigned int fileID, unsigned int imageID, FILE *headerFP, unsigned int *fileCount, unsigned int maxIndices, Defclass *theDefclass, unsigned int *orderedHandlerArrayVersion, unsigned int *orderedHandlerArrayCount, bool *reopenOrderedHandlerFile, struct CodeGeneratorFile *orderedHandlerCodeFile) { long i; if (theDefclass->handlerCount == 0) return true; *orderedHandlerFile = OpenFileIfNeeded(theEnv,*orderedHandlerFile,fileName,pathName,fileNameBuffer,fileID, imageID,fileCount, *orderedHandlerArrayVersion,headerFP, "unsigned",OrderedHandlerPrefix(), *reopenOrderedHandlerFile, orderedHandlerCodeFile); if (*orderedHandlerFile == NULL) return false; for (i = 0 ; i < theDefclass->handlerCount ; i++) { if (i > 0) fprintf(*orderedHandlerFile,","); fprintf(*orderedHandlerFile,"%u",theDefclass->handlerOrderMap[i]); } *orderedHandlerArrayCount += theDefclass->handlerCount; *orderedHandlerFile = CloseFileIfNeeded(theEnv,*orderedHandlerFile,orderedHandlerArrayCount, orderedHandlerArrayVersion,maxIndices, reopenOrderedHandlerFile, orderedHandlerCodeFile); return true; } #endif