src/clipsrules/core/genrccmp.c Source File

00001    /*******************************************************/
00002    /*      "C" Language Integrated Production System      */
00003    /*                                                     */
00004    /*             CLIPS Version 6.24  07/01/05            */
00005    /*                                                     */
00006    /*                                                     */
00007    /*******************************************************/
00008 
00009 /*************************************************************/
00010 /* Purpose: Generic Function Construct Compiler Code         */
00011 /*                                                           */
00012 /* Principal Programmer(s):                                  */
00013 /*      Brian L. Dantes                                      */
00014 /*                                                           */
00015 /* Contributing Programmer(s):                               */
00016 /*                                                           */
00017 /* Revision History:                                         */
00018 /*                                                           */
00019 /*      6.24: Added pragmas to remove unused parameter       */
00020 /*            warnings.                                      */
00021 /*                                                           */
00022 /*************************************************************/
00023 
00024 /* =========================================
00025    *****************************************
00026                EXTERNAL DEFINITIONS
00027    =========================================
00028    ***************************************** */
00029 #include "setup.h"
00030 
00031 #if DEFGENERIC_CONSTRUCT && CONSTRUCT_COMPILER && (! RUN_TIME)
00032 
00033 #if DEFRULE_CONSTRUCT
00034 #include "network.h"
00035 #endif
00036 
00037 #include "genrccom.h"
00038 #include "conscomp.h"
00039 #include "envrnmnt.h"
00040 
00041 #if OBJECT_SYSTEM
00042 #include "objcmp.h"
00043 #endif
00044 
00045 #define _GENRCCMP_SOURCE_
00046 #include "genrccmp.h"
00047 
00048 /* =========================================
00049    *****************************************
00050                    CONSTANTS
00051    =========================================
00052    ***************************************** */
00053 #define MODULEI      0
00054 #define GENERICI     1
00055 #define METHODI      2
00056 #define RESTRICTIONI 3
00057 #define TYPEI        4
00058 
00059 #define SAVE_ITEMS   5
00060 
00061 /* =========================================
00062    *****************************************
00063                MACROS AND TYPES
00064    =========================================
00065    ***************************************** */
00066 #define MethodPrefix()      ArbitraryPrefix(DefgenericData(theEnv)->DefgenericCodeItem,2)
00067 #define RestrictionPrefix() ArbitraryPrefix(DefgenericData(theEnv)->DefgenericCodeItem,3)
00068 #define TypePrefix()        ArbitraryPrefix(DefgenericData(theEnv)->DefgenericCodeItem,4)
00069 
00070 /* =========================================
00071    *****************************************
00072       INTERNALLY VISIBLE FUNCTION HEADERS
00073    =========================================
00074    ***************************************** */
00075 
00076 static void ReadyDefgenericsForCode(void *);
00077 static int DefgenericsToCode(void *,char *,char *,char *,int,FILE *,int,int);
00078 static void CloseDefgenericFiles(void *,FILE *[SAVE_ITEMS],int [SAVE_ITEMS],
00079                                  struct CodeGeneratorFile [SAVE_ITEMS],int);
00080 static void DefgenericModuleToCode(void *,FILE *,struct defmodule *,int,int);
00081 static void SingleDefgenericToCode(void *,FILE *,int,int,DEFGENERIC *,int,int,int);
00082 static void MethodToCode(void *,FILE *,int,DEFMETHOD *,int,int);
00083 static void RestrictionToCode(void *,FILE *,int,RESTRICTION *,int,int);
00084 static void TypeToCode(void *,FILE *,int,void *,int);
00085 
00086 /* =========================================
00087    *****************************************
00088           EXTERNALLY VISIBLE FUNCTIONS
00089    =========================================
00090    ***************************************** */
00091 
00092 /***************************************************
00093   NAME         : SetupGenericsCompiler
00094   DESCRIPTION  : Initializes the construct compiler
00095                    item for generic functions
00096   INPUTS       : None
00097   RETURNS      : Nothing useful
00098   SIDE EFFECTS : Code generator item initialized
00099   NOTES        : None
00100  ***************************************************/
00101 globle void SetupGenericsCompiler(
00102   void *theEnv)
00103   {
00104    DefgenericData(theEnv)->DefgenericCodeItem = AddCodeGeneratorItem(theEnv,"generics",0,ReadyDefgenericsForCode,
00105                                              NULL,DefgenericsToCode,5);
00106   }
00107 
00108 /***************************************************
00109   NAME         : PrintGenericFunctionReference
00110   DESCRIPTION  : Prints a reference to the run-time
00111                  generic array for the construct
00112                  compiler
00113   INPUTS       : 1) The file output destination
00114                  2) A pointer to the generic
00115                  3) The id of the run-time image
00116                  4) The maximum number of indices
00117                     in any array
00118   RETURNS      : Nothing useful
00119   SIDE EFFECTS : Reference printed
00120   NOTES        : None
00121  ***************************************************/
00122 globle void PrintGenericFunctionReference(
00123   void *theEnv,
00124   FILE *fp,
00125   DEFGENERIC *gfunc,
00126   int imageID,
00127   int maxIndices)
00128   {
00129    if (gfunc == NULL)
00130      fprintf(fp,"NULL");
00131    else
00132      fprintf(fp,"&%s%d_%d[%d]",ConstructPrefix(DefgenericData(theEnv)->DefgenericCodeItem),imageID,
00133                                 (int) ((gfunc->header.bsaveID / maxIndices) + 1),
00134                                 (int) (gfunc->header.bsaveID % maxIndices));
00135   }
00136 
00137 /****************************************************
00138   NAME         : DefgenericCModuleReference
00139   DESCRIPTION  : Prints out a reference to a
00140                  defgeneric module
00141   INPUTS       : 1) The output file
00142                  2) The id of the module item
00143                  3) The id of the image
00144                  4) The maximum number of elements
00145                     allowed in an array
00146   RETURNS      : Nothing useful
00147   SIDE EFFECTS : Defgeneric module reference printed
00148   NOTES        : None
00149  ****************************************************/
00150 globle void DefgenericCModuleReference(
00151   void *theEnv,
00152   FILE *theFile,
00153   int count,
00154   int imageID,
00155   int maxIndices)
00156   {
00157    fprintf(theFile,"MIHS &%s%d_%d[%d]",
00158                       ModulePrefix(DefgenericData(theEnv)->DefgenericCodeItem),
00159                       imageID,
00160                       (count / maxIndices) + 1,
00161                       (count % maxIndices));
00162   }
00163 
00164 /* =========================================
00165    *****************************************
00166           INTERNALLY VISIBLE FUNCTIONS
00167    =========================================
00168    ***************************************** */
00169 
00170 /***************************************************
00171   NAME         : ReadyDefgenericsForCode
00172   DESCRIPTION  : Sets index of generic-functions
00173                    for use in compiled expressions
00174   INPUTS       : None
00175   RETURNS      : Nothing useful
00176   SIDE EFFECTS : BsaveIndices set
00177   NOTES        : None
00178  ***************************************************/
00179 static void ReadyDefgenericsForCode(
00180   void *theEnv)
00181   {
00182    MarkConstructBsaveIDs(theEnv,DefgenericData(theEnv)->DefgenericModuleIndex);
00183   }
00184 
00185 /*******************************************************
00186   NAME         : DefgenericsToCode
00187   DESCRIPTION  : Writes out static array code for
00188                    generic functions, methods, etc.
00189   INPUTS       : 1) The base name of the construct set
00190                  2) The base id for this construct
00191                  3) The file pointer for the header file
00192                  4) The base id for the construct set
00193                  5) The max number of indices allowed
00194                     in an array
00195   RETURNS      : -1 if no generic functions, 0 on errors,
00196                   1 if generic functions written
00197   SIDE EFFECTS : Code written to files
00198   NOTES        : None
00199  *******************************************************/
00200 static int DefgenericsToCode(
00201   void *theEnv,
00202   char *fileName,
00203   char *pathName,
00204   char *fileNameBuffer,
00205   int fileID,
00206   FILE *headerFP,
00207   int imageID,
00208   int maxIndices)
00209   {
00210    int fileCount = 1;
00211    struct defmodule *theModule;
00212    DEFGENERIC *theDefgeneric;
00213    DEFMETHOD *theMethod;
00214    RESTRICTION *theRestriction;
00215    short i,j,k;
00216    int moduleCount = 0;
00217    int itemArrayCounts[SAVE_ITEMS];
00218    int itemArrayVersions[SAVE_ITEMS];
00219    FILE *itemFiles[SAVE_ITEMS];
00220    int itemReopenFlags[SAVE_ITEMS];
00221    struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS];
00222 
00223    for (i = 0 ; i < SAVE_ITEMS ; i++)
00224      {
00225       itemArrayCounts[i] = 0;
00226       itemArrayVersions[i] = 1;
00227       itemFiles[i] = NULL;
00228       itemReopenFlags[i] = FALSE;
00229       itemCodeFiles[i].filePrefix = NULL;
00230       itemCodeFiles[i].pathName = pathName;
00231       itemCodeFiles[i].fileNameBuffer = fileNameBuffer;
00232      }
00233 
00234    /* ===========================================
00235       Include the appropriate generic header file
00236       =========================================== */
00237    fprintf(headerFP,"#include \"genrcfun.h\"\n");
00238 
00239    /* =============================================================
00240       Loop through all the modules and all the defgenerics writing
00241       their C code representation to the file as they are traversed
00242       ============================================================= */
00243    theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
00244 
00245    while (theModule != NULL)
00246      {
00247       EnvSetCurrentModule(theEnv,(void *) theModule);
00248 
00249       itemFiles[MODULEI] =
00250          OpenFileIfNeeded(theEnv,itemFiles[MODULEI],fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
00251                           itemArrayVersions[MODULEI],headerFP,
00252                           "DEFGENERIC_MODULE",ModulePrefix(DefgenericData(theEnv)->DefgenericCodeItem),
00253                           itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
00254       if (itemFiles[MODULEI] == NULL)
00255         goto GenericCodeError;
00256 
00257       DefgenericModuleToCode(theEnv,itemFiles[MODULEI],theModule,imageID,maxIndices);
00258       itemFiles[MODULEI] =
00259           CloseFileIfNeeded(theEnv,itemFiles[MODULEI],&itemArrayCounts[MODULEI],
00260                             &itemArrayVersions[MODULEI],maxIndices,
00261                             &itemReopenFlags[MODULEI],&itemCodeFiles[MODULEI]);
00262 
00263       theDefgeneric = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,NULL);
00264 
00265       while (theDefgeneric != NULL)
00266         {
00267          itemFiles[GENERICI] =
00268             OpenFileIfNeeded(theEnv,itemFiles[GENERICI],fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
00269                              itemArrayVersions[GENERICI],headerFP,
00270                              "DEFGENERIC",ConstructPrefix(DefgenericData(theEnv)->DefgenericCodeItem),
00271                              itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
00272          if (itemFiles[GENERICI] == NULL)
00273            goto GenericCodeError;
00274 
00275          SingleDefgenericToCode(theEnv,itemFiles[GENERICI],imageID,maxIndices,theDefgeneric,
00276                                 moduleCount,itemArrayVersions[METHODI],
00277                                 itemArrayCounts[METHODI]);
00278          itemArrayCounts[GENERICI]++;
00279          itemFiles[GENERICI] =
00280            CloseFileIfNeeded(theEnv,itemFiles[GENERICI],&itemArrayCounts[GENERICI],
00281                              &itemArrayVersions[GENERICI],maxIndices,
00282                              &itemReopenFlags[GENERICI],&itemCodeFiles[GENERICI]);
00283          if (theDefgeneric->mcnt > 0)
00284            {
00285 
00286             /* ===========================================
00287                Make sure that all methods for a particular
00288                generic function go into the same array
00289                =========================================== */
00290             itemFiles[METHODI] =
00291                 OpenFileIfNeeded(theEnv,itemFiles[METHODI],fileName,pathName,fileNameBuffer,fileID,imageID,&fileCount,
00292                                  itemArrayVersions[METHODI],headerFP,
00293                                  "DEFMETHOD",MethodPrefix(),
00294                                  itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
00295             if (itemFiles[METHODI] == NULL)
00296               goto GenericCodeError;
00297 
00298             for (i = 0 ; i < theDefgeneric->mcnt ; i++)
00299               {
00300                theMethod = &theDefgeneric->methods[i];
00301                if (i > 0)
00302                  fprintf(itemFiles[METHODI],",\n");
00303                MethodToCode(theEnv,itemFiles[METHODI],imageID,theMethod,
00304                             itemArrayVersions[RESTRICTIONI],itemArrayCounts[RESTRICTIONI]);
00305                if (theMethod->restrictionCount > 0)
00306                  {
00307                   /* ========================================
00308                      Make sure that all restrictions for a
00309                      particular method go into the same array
00310                      ======================================== */
00311                   itemFiles[RESTRICTIONI] =
00312                      OpenFileIfNeeded(theEnv,itemFiles[RESTRICTIONI],fileName,pathName,fileNameBuffer,fileID,
00313                                       imageID,&fileCount,
00314                                       itemArrayVersions[RESTRICTIONI],headerFP,
00315                                       "RESTRICTION",RestrictionPrefix(),
00316                                       itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
00317                   if (itemFiles[RESTRICTIONI] == NULL)
00318                     goto GenericCodeError;
00319                   for (j = 0 ; j < theMethod->restrictionCount ; j++)
00320                     {
00321                      theRestriction = &theMethod->restrictions[j];
00322                      if (j > 0)
00323                        fprintf(itemFiles[RESTRICTIONI],",\n");
00324                      RestrictionToCode(theEnv,itemFiles[RESTRICTIONI],imageID,theRestriction,
00325                                        itemArrayVersions[TYPEI],itemArrayCounts[TYPEI]);
00326 
00327                      if (theRestriction->tcnt > 0)
00328                        {
00329                         /* =========================================
00330                            Make sure that all types for a particular
00331                            restriction go into the same array
00332                            ========================================= */
00333                         itemFiles[TYPEI] =
00334                            OpenFileIfNeeded(theEnv,itemFiles[TYPEI],fileName,pathName,fileNameBuffer,fileID,
00335                                             imageID,&fileCount,
00336                                             itemArrayVersions[TYPEI],headerFP,
00337                                             "void *",TypePrefix(),
00338                                             itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
00339                         if (itemFiles[TYPEI] == NULL)
00340                           goto GenericCodeError;
00341                         for (k = 0 ; k < theRestriction->tcnt ; k++)
00342                           {
00343                            if (k > 0)
00344                              fprintf(itemFiles[TYPEI],",\n");
00345                            TypeToCode(theEnv,itemFiles[TYPEI],imageID,
00346                                       theRestriction->types[k],maxIndices);
00347                           }
00348                         itemArrayCounts[TYPEI] += (int) theRestriction->tcnt;
00349                         itemFiles[TYPEI] =
00350                            CloseFileIfNeeded(theEnv,itemFiles[TYPEI],&itemArrayCounts[TYPEI],
00351                                              &itemArrayVersions[TYPEI],maxIndices,
00352                                              &itemReopenFlags[TYPEI],&itemCodeFiles[TYPEI]);
00353                        }
00354                     }
00355                   itemArrayCounts[RESTRICTIONI] += theMethod->restrictionCount;
00356                   itemFiles[RESTRICTIONI] =
00357                      CloseFileIfNeeded(theEnv,itemFiles[RESTRICTIONI],&itemArrayCounts[RESTRICTIONI],
00358                                        &itemArrayVersions[RESTRICTIONI],maxIndices,
00359                                        &itemReopenFlags[RESTRICTIONI],&itemCodeFiles[RESTRICTIONI]);
00360                  }
00361               }
00362             itemArrayCounts[METHODI] += (int) theDefgeneric->mcnt;
00363             itemFiles[METHODI] =
00364                CloseFileIfNeeded(theEnv,itemFiles[METHODI],&itemArrayCounts[METHODI],
00365                                  &itemArrayVersions[METHODI],maxIndices,
00366                                  &itemReopenFlags[METHODI],&itemCodeFiles[METHODI]);
00367            }
00368          theDefgeneric = (DEFGENERIC *) EnvGetNextDefgeneric(theEnv,theDefgeneric);
00369         }
00370 
00371       theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule);
00372       moduleCount++;
00373       itemArrayCounts[MODULEI]++;
00374      }
00375    CloseDefgenericFiles(theEnv,itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
00376    return(1);
00377 
00378 GenericCodeError:
00379    CloseDefgenericFiles(theEnv,itemFiles,itemReopenFlags,itemCodeFiles,maxIndices);
00380    return(0);
00381   }
00382 
00383 /******************************************************
00384   NAME         : CloseDefgenericFiles
00385   DESCRIPTION  : Closes construct compiler files
00386                   for defgeneric structures
00387   INPUTS       : 1) An array containing all the
00388                     pertinent file pointers
00389                  2) An array containing all the
00390                     pertinent file reopen flags
00391                  3) An array containing all the
00392                     pertinent file name/id/version info
00393                  4) The maximum number of indices
00394                     allowed in an array
00395   RETURNS      : Nothing useful
00396   SIDE EFFECTS : Files closed
00397   NOTES        : None
00398  *****************************************************/
00399 static void CloseDefgenericFiles(
00400   void *theEnv,
00401   FILE *itemFiles[SAVE_ITEMS],
00402   int itemReopenFlags[SAVE_ITEMS],
00403   struct CodeGeneratorFile itemCodeFiles[SAVE_ITEMS],
00404   int maxIndices)
00405   {
00406    int count = maxIndices;
00407    int arrayVersion = 0;
00408    register int i;
00409 
00410    for (i = 0 ; i < SAVE_ITEMS ; i++)
00411      {
00412       count = maxIndices;
00413       itemFiles[i] = CloseFileIfNeeded(theEnv,itemFiles[i],&count,&arrayVersion,
00414                                        maxIndices,&itemReopenFlags[i],
00415                                        &itemCodeFiles[i]);
00416      }
00417   }
00418 
00419 /***************************************************
00420   NAME         : DefgenericModuleToCode
00421   DESCRIPTION  : Writes out the C values for a
00422                  defgeneric module item
00423   INPUTS       : 1) The output file
00424                  2) The module for the defgenerics
00425                  3) The compile image id
00426                  4) The maximum number of elements
00427                     in an array
00428   RETURNS      : Nothing useful
00429   SIDE EFFECTS : Defgeneric module item written
00430   NOTES        : None
00431  ***************************************************/
00432 static void DefgenericModuleToCode(
00433   void *theEnv,
00434   FILE *theFile,
00435   struct defmodule *theModule,
00436   int imageID,
00437   int maxIndices)
00438   {
00439    fprintf(theFile,"{");
00440    ConstructModuleToCode(theEnv,theFile,theModule,imageID,maxIndices,
00441                          DefgenericData(theEnv)->DefgenericModuleIndex,ConstructPrefix(DefgenericData(theEnv)->DefgenericCodeItem));
00442    fprintf(theFile,"}");
00443   }
00444 
00445 /****************************************************************
00446   NAME         : SingleDefgenericToCode
00447   DESCRIPTION  : Writes out a single defgeneric's
00448                  data to the file
00449   INPUTS       : 1)  The output file
00450                  2)  The compile image id
00451                  3)  The maximum number of
00452                      elements in an array
00453                  4)  The defgeneric
00454                  5)  The module index
00455                  6)  The partition holding the
00456                      generic methods
00457                  7) The relative index of the
00458                     generics methods in the partition
00459   RETURNS      : Nothing useful
00460   SIDE EFFECTS : Defgeneric data written
00461   NOTES        : None
00462  ***************************************************************/
00463 static void SingleDefgenericToCode(
00464   void *theEnv,
00465   FILE *theFile,
00466   int imageID,
00467   int maxIndices,
00468   DEFGENERIC *theDefgeneric,
00469   int moduleCount,
00470   int methodArrayVersion,
00471   int methodArrayCount)
00472   {
00473    /* ==================
00474       Defgeneric Header
00475       ================== */
00476    fprintf(theFile,"{");
00477    ConstructHeaderToCode(theEnv,theFile,&theDefgeneric->header,imageID,maxIndices,moduleCount,
00478                          ModulePrefix(DefgenericData(theEnv)->DefgenericCodeItem),
00479                          ConstructPrefix(DefgenericData(theEnv)->DefgenericCodeItem));
00480 
00481    /* =========================
00482       Defgeneric specific data
00483       ========================= */
00484    fprintf(theFile,",0,0,");
00485    if (theDefgeneric->methods == NULL)
00486      fprintf(theFile,"NULL");
00487    else
00488      {
00489       fprintf(theFile,"&%s%d_%d[%d]",MethodPrefix(),imageID,
00490                       methodArrayVersion,methodArrayCount);
00491      }
00492    fprintf(theFile,",%hd,0}",theDefgeneric->mcnt);
00493   }
00494 
00495 /****************************************************************
00496   NAME         : MethodToCode
00497   DESCRIPTION  : Writes out a single method's
00498                  data to the file
00499   INPUTS       : 1)  The output file
00500                  2)  The compile image id
00501                  3)  The method
00502                  4)  The partition holding the
00503                      method restrictions
00504                  5) The relative index of the
00505                     method restrictions in the partition
00506   RETURNS      : Nothing useful
00507   SIDE EFFECTS : Method data written
00508   NOTES        : None
00509  ***************************************************************/
00510 static void MethodToCode(
00511   void *theEnv,
00512   FILE *theFile,
00513   int imageID,
00514   DEFMETHOD *theMethod,
00515   int restrictionArrayVersion,
00516   int restrictionArrayCount)
00517   {
00518    fprintf(theFile,"{%hd,0,%hd,%hd,%hd,%hd,%u,0,",
00519                    theMethod->index,theMethod->restrictionCount,
00520                    theMethod->minRestrictions,theMethod->maxRestrictions,
00521                    theMethod->localVarCount,theMethod->system);
00522    if (theMethod->restrictions == NULL)
00523      fprintf(theFile,"NULL,");
00524    else
00525      fprintf(theFile,"&%s%d_%d[%d],",RestrictionPrefix(),imageID,
00526                                      restrictionArrayVersion,restrictionArrayCount);
00527    ExpressionToCode(theEnv,theFile,theMethod->actions);
00528    fprintf(theFile,",NULL}");
00529   }
00530 
00531 /****************************************************************
00532   NAME         : RestrictionToCode
00533   DESCRIPTION  : Writes out a single restriction's
00534                  data to the file
00535   INPUTS       : 1)  The output file
00536                  2)  The compile image id
00537                  3)  The restriction
00538                  4)  The partition holding the
00539                      restriction types
00540                  5) The relative index of the
00541                     restriction types in the partition
00542   RETURNS      : Nothing useful
00543   SIDE EFFECTS : Restriction data written
00544   NOTES        : None
00545  ***************************************************************/
00546 static void RestrictionToCode(
00547   void *theEnv,
00548   FILE *theFile,
00549   int imageID,
00550   RESTRICTION *theRestriction,
00551   int typeArrayVersion,
00552   int typeArrayCount)
00553   {
00554    fprintf(theFile,"{");
00555    if (theRestriction->types == NULL)
00556      fprintf(theFile,"NULL,");
00557    else
00558      fprintf(theFile,"&%s%d_%d[%d],",TypePrefix(),imageID,
00559                                      typeArrayVersion,typeArrayCount);
00560    ExpressionToCode(theEnv,theFile,theRestriction->query);
00561    fprintf(theFile,",%hd}",theRestriction->tcnt);
00562   }
00563 
00564 /****************************************************************
00565   NAME         : TypeToCode
00566   DESCRIPTION  : Writes out a single type's
00567                  data to the file
00568   INPUTS       : 1)  The output file
00569                  2)  The compile image id
00570                  3)  The type
00571   RETURNS      : Nothing useful
00572   SIDE EFFECTS : Type data written
00573   NOTES        : None
00574  ***************************************************************/
00575 static void TypeToCode(
00576   void *theEnv,
00577   FILE *theFile,
00578   int imageID,
00579   void *theType,
00580   int maxIndices)
00581   {
00582 #if OBJECT_SYSTEM
00583    fprintf(theFile,"VS ");
00584    PrintClassReference(theEnv,theFile,(DEFCLASS *) theType,imageID,maxIndices);
00585 #else
00586 
00587 #if MAC_MCW || WIN_MCW || MAC_XCD
00588 #pragma unused(imageID)
00589 #pragma unused(maxIndices)
00590 #endif
00591 
00592    PrintIntegerReference(theEnv,theFile,(INTEGER_HN *) theType);
00593 #endif
00594   }
00595 
00596 
00597 #endif