自学教程：C++ DeffunctionData函数代码示例

static void DeallocateDeffunctionData(  void *theEnv)  {#if ! RUN_TIME   struct deffunctionModule *theModuleItem;   void *theModule;#if BLOAD || BLOAD_AND_BSAVE   if (Bloaded(theEnv)) return;#endif   DoForAllConstructs(theEnv,DestroyDeffunctionAction,DeffunctionData(theEnv)->DeffunctionModuleIndex,FALSE,NULL);    for (theModule = EnvGetNextDefmodule(theEnv,NULL);        theModule != NULL;        theModule = EnvGetNextDefmodule(theEnv,theModule))     {      theModuleItem = (struct deffunctionModule *)                      GetModuleItem(theEnv,(struct defmodule *) theModule,                                    DeffunctionData(theEnv)->DeffunctionModuleIndex);      rtn_struct(theEnv,deffunctionModule,theModuleItem);     }#else#endif  }

/***************************************************  NAME         : SingleDeffunctionToCode  DESCRIPTION  : Writes out a single deffunction's                 data to the file  INPUTS       : 1) The output file                 2) The deffunction                 3) The compile image id                 4) The maximum number of                    elements in an array                 5) The module index  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction data written  NOTES        : None ***************************************************/static void SingleDeffunctionToCode(  void *theEnv,  FILE *theFile,  DEFFUNCTION *theDeffunction,  int imageID,  int maxIndices,  int moduleCount)  {   /* ==================      Deffunction Header      ================== */   fprintf(theFile,"{");   ConstructHeaderToCode(theEnv,theFile,&theDeffunction->header,imageID,maxIndices,moduleCount,                         ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),                         ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem));   /* =========================      Deffunction specific data      ========================= */   fprintf(theFile,",0,0,0,");   ExpressionToCode(theEnv,theFile,theDeffunction->code);   fprintf(theFile,",%d,%d,%d",           theDeffunction->minNumberOfParameters,           theDeffunction->maxNumberOfParameters,           theDeffunction->numberOfLocalVars);   fprintf(theFile,"}");  }

static void DeallocateDeffunctionData(  void *theEnv,  EXEC_STATUS)  {#if ! RUN_TIME   struct deffunctionModule *theModuleItem;   void *theModule;#if BLOAD || BLOAD_AND_BSAVE   if (Bloaded(theEnv,execStatus)) return;#endif   DoForAllConstructs(theEnv,execStatus,DestroyDeffunctionAction,DeffunctionData(theEnv,execStatus)->DeffunctionModuleIndex,FALSE,NULL);    for (theModule = EnvGetNextDefmodule(theEnv,execStatus,NULL);        theModule != NULL;        theModule = EnvGetNextDefmodule(theEnv,execStatus,theModule))     {      theModuleItem = (struct deffunctionModule *)                      GetModuleItem(theEnv,execStatus,(struct defmodule *) theModule,                                    DeffunctionData(theEnv,execStatus)->DeffunctionModuleIndex);      rtn_struct(theEnv,execStatus,deffunctionModule,theModuleItem);     }#else#if MAC_MCW || WIN_MCW || MAC_XCD#pragma unused(theEnv,execStatus)#endif#endif  }

/***************************************************************  NAME         : GetDeffunctionListFunction  DESCRIPTION  : Groups all deffunction names into                 a multifield list  INPUTS       : A data object buffer to hold                 the multifield result  RETURNS      : Nothing useful  SIDE EFFECTS : Multifield allocated and filled  NOTES        : H/L Syntax: (get-deffunction-list [<module>]) ***************************************************************/globle void GetDeffunctionListFunction(  void *theEnv,  EXEC_STATUS,  DATA_OBJECT *returnValue)  {   GetConstructListFunction(theEnv,execStatus,"get-deffunction-list",returnValue,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct);  }

/***************************************************  NAME         : LookupDeffunctionInScope  DESCRIPTION  : Finds a deffunction in current or                   imported modules (module                   specifier is not allowed)  INPUTS       : The deffunction name  RETURNS      : The deffunction (NULL if not found)  SIDE EFFECTS : Error message printed on                  ambiguous references  NOTES        : None ***************************************************/globle DEFFUNCTION *LookupDeffunctionInScope(  void *theEnv,  EXEC_STATUS,  char *deffunctionName)  {   return((DEFFUNCTION *) LookupConstruct(theEnv,execStatus,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct,deffunctionName,FALSE));  }

/***************************************************  NAME         : BsaveDeffunctionExpressions  DESCRIPTION  : Writes out all expressions needed                   by deffunctyions  INPUTS       : The file pointer of the binary file  RETURNS      : Nothing useful  SIDE EFFECTS : File updated  NOTES        : None ***************************************************/static void BsaveDeffunctionExpressions(    void *theEnv,    FILE *fp){    DoForAllConstructs(theEnv,BsaveDeffunctionExpression,DeffunctionData(theEnv)->DeffunctionModuleIndex,                       FALSE,(void *) fp);}

/***************************************************  NAME         : EnvListDeffunctions  DESCRIPTION  : Displays all deffunction names  INPUTS       : 1) The logical name of the output                 2) The module  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction name sprinted  NOTES        : C Interface ***************************************************/globle void EnvListDeffunctions(  void *theEnv,  char *logicalName,  struct defmodule *theModule)  {   ListConstruct(theEnv,DeffunctionData(theEnv)->DeffunctionConstruct,logicalName,theModule);  }

/***************************************************  NAME         : UpdateDeffunction  DESCRIPTION  : Updates deffunction with binary                 load data - sets pointers from                 offset information  INPUTS       : 1) A pointer to the bloaded data                 2) The index of the binary array                    element to update  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction pointers upadted  NOTES        : None ***************************************************/static void UpdateDeffunction(    void *theEnv,    void *buf,    long obji){    BSAVE_DEFFUNCTION *bdptr;    DEFFUNCTION *dptr;    bdptr = (BSAVE_DEFFUNCTION *) buf;    dptr = (DEFFUNCTION *) &DeffunctionBinaryData(theEnv)->DeffunctionArray[obji];    UpdateConstructHeader(theEnv,&bdptr->header,&dptr->header,                          (int) sizeof(DEFFUNCTION_MODULE),(void *) DeffunctionBinaryData(theEnv)->ModuleArray,                          (int) sizeof(DEFFUNCTION),(void *) DeffunctionBinaryData(theEnv)->DeffunctionArray);    dptr->code = ExpressionPointer(bdptr->code);    dptr->busy = 0;    dptr->executing = 0;#if DEBUGGING_FUNCTIONS    dptr->trace = (unsigned short) DeffunctionData(theEnv)->WatchDeffunctions;#endif    dptr->minNumberOfParameters = bdptr->minNumberOfParameters;    dptr->maxNumberOfParameters = bdptr->maxNumberOfParameters;    dptr->numberOfLocalVars = bdptr->numberOfLocalVars;}

/***************************************************************  NAME         : EnvGetDeffunctionList  DESCRIPTION  : Groups all deffunction names into                 a multifield list  INPUTS       : 1) A data object buffer to hold                    the multifield result                 2) The module from which to obtain deffunctions  RETURNS      : Nothing useful  SIDE EFFECTS : Multifield allocated and filled  NOTES        : External C access ***************************************************************/globle void EnvGetDeffunctionList(  void *theEnv,  DATA_OBJECT *returnValue,  struct defmodule *theModule)  {   GetConstructList(theEnv,returnValue,DeffunctionData(theEnv)->DeffunctionConstruct,theModule);  }

/***************************************************  NAME         : SaveDeffunctions  DESCRIPTION  : Writes out deffunctions                 for (save) command  INPUTS       : The logical output name  RETURNS      : Nothing useful  SIDE EFFECTS : Writes out deffunctions  NOTES        : None ***************************************************/static void SaveDeffunctions(  void *theEnv,  void *theModule,  char *logicalName)  {   SaveConstruct(theEnv,theModule,logicalName,DeffunctionData(theEnv)->DeffunctionConstruct);  }

/*******************************************************  NAME         : UnboundDeffunctionErr  DESCRIPTION  : Print out a synopis of the currently                   executing deffunction for unbound                   variable errors  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Error synopsis printed to WERROR  NOTES        : None *******************************************************/static void UnboundDeffunctionErr(  void *theEnv)  {   EnvPrintRouter(theEnv,WERROR,"deffunction ");   EnvPrintRouter(theEnv,WERROR,EnvGetDeffunctionName(theEnv,(void *) DeffunctionData(theEnv)->ExecutingDeffunction));   EnvPrintRouter(theEnv,WERROR,"./n");  }

/***************************************************  NAME         : EnvFindDeffunction  DESCRIPTION  : Searches for a deffunction  INPUTS       : The name of the deffunction                 (possibly including a module name)  RETURNS      : Pointer to the deffunction if                 found, otherwise NULL  SIDE EFFECTS : None  NOTES        : None ***************************************************/globle void *EnvFindDeffunction(  void *theEnv,  EXEC_STATUS,  char *dfnxModuleAndName)  {   return(FindNamedConstruct(theEnv,execStatus,dfnxModuleAndName,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct));  }

/***************************************************************  NAME         : EnvGetDeffunctionList  DESCRIPTION  : Groups all deffunction names into                 a multifield list  INPUTS       : 1) A data object buffer to hold                    the multifield result                 2) The module from which to obtain deffunctions  RETURNS      : Nothing useful  SIDE EFFECTS : Multifield allocated and filled  NOTES        : External C access ***************************************************************/globle void EnvGetDeffunctionList(  void *theEnv,  EXEC_STATUS,  DATA_OBJECT *returnValue,  struct defmodule *theModule)  {   GetConstructList(theEnv,execStatus,returnValue,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct,theModule);  }

/***************************************************  NAME         : WatchDeffunction  DESCRIPTION  : Displays a message indicating when                 a deffunction began and ended                 execution  INPUTS       : The beginning or end trace string                 to print when deffunction starts                 or finishes respectively  RETURNS      : Nothing useful  SIDE EFFECTS : Watch message printed  NOTES        : None ***************************************************/static void WatchDeffunction(  void *theEnv,  char *tstring)  {   EnvPrintRouter(theEnv,WTRACE,"DFN ");   EnvPrintRouter(theEnv,WTRACE,tstring);   if (DeffunctionData(theEnv)->ExecutingDeffunction->header.whichModule->theModule != ((struct defmodule *) EnvGetCurrentModule(theEnv)))     {      EnvPrintRouter(theEnv,WTRACE,EnvGetDefmoduleName(theEnv,(void *)                        DeffunctionData(theEnv)->ExecutingDeffunction->header.whichModule->theModule));      EnvPrintRouter(theEnv,WTRACE,"::");     }   EnvPrintRouter(theEnv,WTRACE,ValueToString(DeffunctionData(theEnv)->ExecutingDeffunction->header.name));   EnvPrintRouter(theEnv,WTRACE," ED:");   PrintLongInteger(theEnv,WTRACE,(long long) EvaluationData(theEnv)->CurrentEvaluationDepth);   PrintProcParamArray(theEnv,WTRACE);  }

/***************************************************  NAME         : EnvListDeffunctions  DESCRIPTION  : Displays all deffunction names  INPUTS       : 1) The logical name of the output                 2) The module  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction name sprinted  NOTES        : C Interface ***************************************************/globle void EnvListDeffunctions(  void *theEnv,  EXEC_STATUS,  char *logicalName,  struct defmodule *theModule)  {   ListConstruct(theEnv,execStatus,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct,logicalName,theModule);  }

/***************************************************  NAME         : SaveDeffunctions  DESCRIPTION  : Writes out deffunctions                 for (save) command  INPUTS       : The logical output name  RETURNS      : Nothing useful  SIDE EFFECTS : Writes out deffunctions  NOTES        : None ***************************************************/static void SaveDeffunctions(  void *theEnv,  EXEC_STATUS,  void *theModule,  char *logicalName)  {   SaveConstruct(theEnv,execStatus,theModule,logicalName,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct);  }

/***************************************************  NAME         : ReturnModule  DESCRIPTION  : Removes a deffunction module and                 all associated deffunctions  INPUTS       : The deffunction module  RETURNS      : Nothing useful  SIDE EFFECTS : Module and deffunctions deleted  NOTES        : None ***************************************************/static void ReturnModule(  void *theEnv,  void *theItem)  {#if (! BLOAD_ONLY)   FreeConstructHeaderModule(theEnv,(struct defmoduleItemHeader *) theItem,DeffunctionData(theEnv)->DeffunctionConstruct);#endif   rtn_struct(theEnv,deffunctionModule,theItem);  }

/***************************************************  NAME         : SaveDeffunctionHeaders  DESCRIPTION  : Writes out deffunction forward                 declarations for (save) command  INPUTS       : The logical output name  RETURNS      : Nothing useful  SIDE EFFECTS : Writes out deffunctions with no                 body of actions  NOTES        : Used for deffunctions which are                 mutually recursive with other                 constructs ***************************************************/static void SaveDeffunctionHeaders(  void *theEnv,  void *theModule,  char *logicalName)  {   DoForAllConstructsInModule(theEnv,theModule,SaveDeffunctionHeader,                              DeffunctionData(theEnv)->DeffunctionModuleIndex,                              FALSE,(void *) logicalName);  }

/***********************************************************************  NAME         : DeffunctionWatchPrint  DESCRIPTION  : Parses a list of deffunction names passed by                 AddWatchItem() and displays the traces accordingly  INPUTS       : 1) The logical name of the output                 2) A code indicating which trace flag is to be examined                    Ignored                 3) A list of expressions containing the names                    of the deffunctions for which to examine traces  RETURNS      : TRUE if all OK, FALSE otherwise  SIDE EFFECTS : Watch flags displayed for specified deffunctions  NOTES        : Accessory function for AddWatchItem() ***********************************************************************/static unsigned DeffunctionWatchPrint(  void *theEnv,  char *logName,  int code,  EXPRESSION *argExprs)  {   return(ConstructPrintWatchAccess(theEnv,DeffunctionData(theEnv)->DeffunctionConstruct,logName,argExprs,                                    EnvGetDeffunctionWatch,EnvSetDeffunctionWatch));  }

/***************************************************************************  NAME         : BsaveDeffunctionFind  DESCRIPTION  : For all deffunctions, this routine marks all                   the needed symbols.                 Also, it also counts the number of                   expression structures needed.                 Also, counts total number of deffunctions.  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented                   for every expression needed                 Symbols are marked in their structures  NOTES        : Also sets bsaveIndex for each deffunction (assumes                   deffunctions will be bsaved in order of binary list) ***************************************************************************/static void BsaveDeffunctionFind(    void *theEnv){    SaveBloadCount(theEnv,DeffunctionBinaryData(theEnv)->ModuleCount);    SaveBloadCount(theEnv,DeffunctionBinaryData(theEnv)->DeffunctionCount);    DeffunctionBinaryData(theEnv)->DeffunctionCount = 0L;    DeffunctionBinaryData(theEnv)->ModuleCount =        DoForAllConstructs(theEnv,MarkDeffunctionItems,DeffunctionData(theEnv)->DeffunctionModuleIndex,                           FALSE,NULL);}

/***************************************************  NAME         : DeffunctionModuleToCode  DESCRIPTION  : Writes out the C values for a                 deffunction module item  INPUTS       : 1) The output file                 2) The module for the deffunctions                 3) The compile image id                 4) The maximum number of elements                    in an array  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction module item written  NOTES        : None ***************************************************/static void DeffunctionModuleToCode(  void *theEnv,  FILE *theFile,  struct defmodule *theModule,  int imageID,  int maxIndices)  {   fprintf(theFile,"{");   ConstructModuleToCode(theEnv,theFile,theModule,imageID,maxIndices,                         DeffunctionData(theEnv)->DeffunctionModuleIndex,ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem));   fprintf(theFile,"}");  }

/****************************************************  NAME         : DeffunctionCModuleReference  DESCRIPTION  : Prints out a reference to a                 deffunction 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 : Deffunction module reference printed  NOTES        : None ****************************************************/void DeffunctionCModuleReference(  void *theEnv,  FILE *theFile,  int count,  int imageID,  int maxIndices)  {   fprintf(theFile,"MIHS &%s%d_%d[%d]",                      ModulePrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),                      imageID,                      (count / maxIndices) + 1,                      (count % maxIndices));  }

/***************************************************  NAME         : PrintDeffunctionReference  DESCRIPTION  : Prints a reference to the run-time                 deffunction array for the construct                 compiler  INPUTS       : 1) The file output destination                 2) A pointer to the deffunction                 3) The id of the run-time image                 4) The maximum number of indices                    in any array  RETURNS      : Nothing useful  SIDE EFFECTS : Reference printed  NOTES        : None ***************************************************/void PrintDeffunctionReference(  void *theEnv,  FILE *fp,  DEFFUNCTION *dfPtr,  int imageID,  int maxIndices)  {   if (dfPtr == NULL)     fprintf(fp,"NULL");   else     fprintf(fp,"&%s%d_%d[%d]",ConstructPrefix(DeffunctionData(theEnv)->DeffunctionCodeItem),imageID,                               (int) ((dfPtr->header.bsaveID / maxIndices) + 1),                               (int) (dfPtr->header.bsaveID % maxIndices));  }

static unsigned DeffunctionWatchAccess(  void *theEnv,  EXEC_STATUS,  int code,  unsigned newState,  EXPRESSION *argExprs)  {#if MAC_MCW || WIN_MCW || MAC_XCD#pragma unused(code)#endif   return(ConstructSetWatchAccess(theEnv,execStatus,DeffunctionData(theEnv,execStatus)->DeffunctionConstruct,newState,argExprs,                                    EnvGetDeffunctionWatch,EnvSetDeffunctionWatch));  }

/*************************************************************************************  NAME         : BsaveDeffunctions  DESCRIPTION  : Writes out deffunction in binary format                 Space required (unsigned long)                 All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions)  INPUTS       : File pointer of binary file  RETURNS      : Nothing useful  SIDE EFFECTS : Binary file adjusted  NOTES        : None *************************************************************************************/static void BsaveDeffunctions(    void *theEnv,    FILE *fp){    size_t space;    struct defmodule *theModule;    DEFFUNCTION_MODULE *theModuleItem;    BSAVE_DEFFUNCTION_MODULE dummy_mitem;    space = ((sizeof(BSAVE_DEFFUNCTION_MODULE) * DeffunctionBinaryData(theEnv)->ModuleCount) +             (sizeof(BSAVE_DEFFUNCTION) * DeffunctionBinaryData(theEnv)->DeffunctionCount));    GenWrite((void *) &space,sizeof(size_t),fp);    /* =================================       Write out each deffunction module       ================================= */    DeffunctionBinaryData(theEnv)->DeffunctionCount = 0L;    theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);    while (theModule != NULL)    {        theModuleItem = (DEFFUNCTION_MODULE *)                        GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"deffunction")->moduleIndex);        AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);        GenWrite((void *) &dummy_mitem,sizeof(BSAVE_DEFFUNCTION_MODULE),fp);        theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);    }    /* ==========================       Write out each deffunction       ========================== */    DoForAllConstructs(theEnv,BsaveDeffunction,DeffunctionData(theEnv)->DeffunctionModuleIndex,                       FALSE,(void *) fp);    RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->ModuleCount);    RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->DeffunctionCount);}

/***************************************************  NAME         : ClearDeffunctionsReady  DESCRIPTION  : Determines if it is safe to                 remove all deffunctions                 Assumes *all* constructs will be                 deleted - only checks to see if                 any deffunctions are currently                 executing  INPUTS       : None  RETURNS      : TRUE if no deffunctions are                 executing, FALSE otherwise  SIDE EFFECTS : None  NOTES        : Used by (clear) and (bload) ***************************************************/static intBool ClearDeffunctionsReady(  void *theEnv)  {   return((DeffunctionData(theEnv)->ExecutingDeffunction != NULL) ? FALSE : TRUE);  }

/***************************************************************  NAME         : GetDeffunctionListFunction  DESCRIPTION  : Groups all deffunction names into                 a multifield list  INPUTS       : A data object buffer to hold                 the multifield result  RETURNS      : Nothing useful  SIDE EFFECTS : Multifield allocated and filled  NOTES        : H/L Syntax: (get-deffunction-list [<module>]) ***************************************************************/globle void GetDeffunctionListFunction(  void *theEnv,  DATA_OBJECT *returnValue)  {   GetConstructListFunction(theEnv,(char*)"get-deffunction-list",returnValue,DeffunctionData(theEnv)->DeffunctionConstruct);  }

/***************************************************  NAME         : ListDeffunctionsCommand  DESCRIPTION  : Displays all deffunction names  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Deffunction name sprinted  NOTES        : H/L Interface ***************************************************/globle void ListDeffunctionsCommand(  void *theEnv)  {   ListConstructCommand(theEnv,(char*)"list-deffunctions",DeffunctionData(theEnv)->DeffunctionConstruct);  }

/****************************************************  NAME         : PPDeffunctionCommand  DESCRIPTION  : Displays the pretty-print form of a                 deffunction  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Pretty-print form displayed to                 WDISPLAY logical name  NOTES        : H/L Syntax: (ppdeffunction <name>) ****************************************************/globle void PPDeffunctionCommand(  void *theEnv)  {   PPConstructCommand(theEnv,(char*)"ppdeffunction",DeffunctionData(theEnv)->DeffunctionConstruct);  }