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

globle void InitializeStringRouter(  void *theEnv)  {   AllocateEnvironmentData(theEnv,STRING_ROUTER_DATA,sizeof(struct stringRouterData),DeallocateStringRouterData);   EnvAddRouter(theEnv,(char*)"string",0,FindString,PrintString,GetcString,UngetcString,NULL);  }

globle void ProceduralFunctionDefinitions(  void *theEnv)  {   AllocateEnvironmentData(theEnv,PRCDRFUN_DATA,sizeof(struct procedureFunctionData),DeallocateProceduralFunctionData);#if ! RUN_TIME   EnvDefineFunction2(theEnv,"if", 'u', PTIEF IfFunction, "IfFunction", NULL);   EnvDefineFunction2(theEnv,"while", 'u', PTIEF WhileFunction, "WhileFunction", NULL);   EnvDefineFunction2(theEnv,"loop-for-count",'u', PTIEF LoopForCountFunction, "LoopForCountFunction", NULL);   EnvDefineFunction2(theEnv,"(get-loop-count)",'g', PTIEF GetLoopCount, "GetLoopCount", NULL);   EnvDefineFunction2(theEnv,"bind", 'u', PTIEF BindFunction, "BindFunction", NULL);   EnvDefineFunction2(theEnv,"progn", 'u', PTIEF PrognFunction, "PrognFunction", NULL);   EnvDefineFunction2(theEnv,"return", 'u', PTIEF ReturnFunction, "ReturnFunction",NULL);   EnvDefineFunction2(theEnv,"break", 'v', PTIEF BreakFunction, "BreakFunction",NULL);   EnvDefineFunction2(theEnv,"switch", 'u', PTIEF SwitchFunction, "SwitchFunction",NULL);   ProceduralFunctionParsers(theEnv);   FuncSeqOvlFlags(theEnv,"progn",FALSE,FALSE);   FuncSeqOvlFlags(theEnv,"if",FALSE,FALSE);   FuncSeqOvlFlags(theEnv,"while",FALSE,FALSE);   FuncSeqOvlFlags(theEnv,"loop-for-count",FALSE,FALSE);   FuncSeqOvlFlags(theEnv,"return",FALSE,FALSE);   FuncSeqOvlFlags(theEnv,"switch",FALSE,FALSE);#endif   EnvAddResetFunction(theEnv,"bind",FlushBindList,0);   EnvAddClearFunction(theEnv,"bind",FlushBindList,0);  }

globle void InitializeMemory(  void *theEnv)  {   AllocateEnvironmentData(theEnv,MEMORY_DATA,sizeof(struct memoryData),NULL);   MemoryData(theEnv)->OutOfMemoryFunction = DefaultOutOfMemoryFunction;#if (MEM_TABLE_SIZE > 0)   MemoryData(theEnv)->MemoryTable = (struct memoryPtr **)                 malloc((STD_SIZE) (sizeof(struct memoryPtr *) * MEM_TABLE_SIZE));   if (MemoryData(theEnv)->MemoryTable == NULL)     {      PrintErrorID(theEnv,"MEMORY",1,TRUE);      EnvPrintRouter(theEnv,WERROR,"Out of memory./n");      EnvExitRouter(theEnv,EXIT_FAILURE);     }   else     {      int i;            for (i = 0; i < MEM_TABLE_SIZE; i++) MemoryData(theEnv)->MemoryTable[i] = NULL;     }#else // MEM_TABLE_SIZE == 0      MemoryData(theEnv)->MemoryTable = NULL;#endif   }

globle void InitializeDefrules(  void *theEnv)  {      AllocateEnvironmentData(theEnv,DEFRULE_DATA,sizeof(struct defruleData),DeallocateDefruleData);   InitializeEngine(theEnv);   InitializeAgenda(theEnv);   InitializePatterns(theEnv);   InitializeDefruleModules(theEnv);   AddReservedPatternSymbol(theEnv,"and",NULL);   AddReservedPatternSymbol(theEnv,"not",NULL);   AddReservedPatternSymbol(theEnv,"or",NULL);   AddReservedPatternSymbol(theEnv,"test",NULL);   AddReservedPatternSymbol(theEnv,"logical",NULL);   AddReservedPatternSymbol(theEnv,"exists",NULL);   AddReservedPatternSymbol(theEnv,"forall",NULL);   DefruleBasicCommands(theEnv);   DefruleCommands(theEnv);   DefruleData(theEnv)->DefruleConstruct =      AddConstruct(theEnv,"defrule","defrules",                   ParseDefrule,EnvFindDefrule,                   GetConstructNamePointer,GetConstructPPForm,                   GetConstructModuleItem,EnvGetNextDefrule,SetNextConstruct,                   EnvIsDefruleDeletable,EnvUndefrule,ReturnDefrule);  }

globle void ConstructProfilingFunctionDefinitions(  void *theEnv)  {   struct userDataRecord profileDataInfo = { 0, CreateProfileData, DeleteProfileData };   AllocateEnvironmentData(theEnv,PROFLFUN_DATA,sizeof(struct profileFunctionData),NULL);   memcpy(&ProfileFunctionData(theEnv)->ProfileDataInfo,&profileDataInfo,sizeof(struct userDataRecord));         ProfileFunctionData(theEnv)->LastProfileInfo = NO_PROFILE;   ProfileFunctionData(theEnv)->PercentThreshold = 0.0;   ProfileFunctionData(theEnv)->OutputString = OUTPUT_STRING;#if ! RUN_TIME   EnvDefineFunction2(theEnv,"profile",'v', PTIEF ProfileCommand,"ProfileCommand","11w");   EnvDefineFunction2(theEnv,"profile-info",'v', PTIEF ProfileInfoCommand,"ProfileInfoCommand","01w");   EnvDefineFunction2(theEnv,"profile-reset",'v', PTIEF ProfileResetCommand,"ProfileResetCommand","00");   EnvDefineFunction2(theEnv,"set-profile-percent-threshold",'d',                   PTIEF SetProfilePercentThresholdCommand,                   "SetProfilePercentThresholdCommand","11n");   EnvDefineFunction2(theEnv,"get-profile-percent-threshold",'d',                   PTIEF GetProfilePercentThresholdCommand,                   "GetProfilePercentThresholdCommand","00");                      ProfileFunctionData(theEnv)->ProfileDataID = InstallUserDataRecord(theEnv,&ProfileFunctionData(theEnv)->ProfileDataInfo);      EnvAddClearFunction(theEnv,"profile",ProfileClearFunction,0);#endif  }

void ConstructProfilingFunctionDefinitions(  Environment *theEnv)  {   struct userDataRecord profileDataInfo = { 0, CreateProfileData, DeleteProfileData };   AllocateEnvironmentData(theEnv,PROFLFUN_DATA,sizeof(struct profileFunctionData),NULL);   memcpy(&ProfileFunctionData(theEnv)->ProfileDataInfo,&profileDataInfo,sizeof(struct userDataRecord));   ProfileFunctionData(theEnv)->LastProfileInfo = NO_PROFILE;   ProfileFunctionData(theEnv)->PercentThreshold = 0.0;   ProfileFunctionData(theEnv)->OutputString = OUTPUT_STRING;#if ! RUN_TIME   AddUDF(theEnv,"profile","v",1,1,"y",ProfileCommand,"ProfileCommand",NULL);   AddUDF(theEnv,"profile-info","v",0,0,NULL, ProfileInfoCommand,"ProfileInfoCommand",NULL);   AddUDF(theEnv,"profile-reset","v",0,0,NULL,ProfileResetCommand,"ProfileResetCommand",NULL);   AddUDF(theEnv,"set-profile-percent-threshold","d",1,1,"ld",SetProfilePercentThresholdCommand,"SetProfilePercentThresholdCommand",NULL);   AddUDF(theEnv,"get-profile-percent-threshold","d",0,0,NULL,GetProfilePercentThresholdCommand,"GetProfilePercentThresholdCommand",NULL);   ProfileFunctionData(theEnv)->ProfileDataID = InstallUserDataRecord(theEnv,&ProfileFunctionData(theEnv)->ProfileDataInfo);   AddClearFunction(theEnv,"profile",ProfileClearFunction,0,NULL);#endif  }

globle void InitializeConstraints(  void *theEnv)  {#if (! RUN_TIME) && (! BLOAD_ONLY)   int i;#endif   AllocateEnvironmentData(theEnv,CONSTRAINT_DATA,sizeof(struct constraintData),DeallocateConstraintData);      ConstraintData(theEnv)->StaticConstraintChecking = TRUE;   #if (! RUN_TIME) && (! BLOAD_ONLY)    ConstraintData(theEnv)->ConstraintHashtable = (struct constraintRecord **)                          gm2(theEnv,(int) sizeof (struct constraintRecord *) *                                    SIZE_CONSTRAINT_HASH);    if (ConstraintData(theEnv)->ConstraintHashtable == NULL) EnvExitRouter(theEnv,EXIT_FAILURE);    for (i = 0; i < SIZE_CONSTRAINT_HASH; i++) ConstraintData(theEnv)->ConstraintHashtable[i] = NULL;#endif#if (! RUN_TIME)   EnvDefineFunction2(theEnv,"get-dynamic-constraint-checking",'b',GDCCommand,"GDCCommand", "00");   EnvDefineFunction2(theEnv,"set-dynamic-constraint-checking",'b',SDCCommand,"SDCCommand", "11");   EnvDefineFunction2(theEnv,"get-static-constraint-checking",'b',GSCCommand,"GSCCommand", "00");   EnvDefineFunction2(theEnv,"set-static-constraint-checking",'b',SSCCommand,"SSCCommand", "11");#endif  }

globle void InitializeDeftemplates(  void *theEnv)  {   globle struct entityRecord deftemplatePtrRecord = { "DEFTEMPLATE_PTR",                                                           DEFTEMPLATE_PTR,1,0,0,                                                           NULL,                                                           NULL,NULL,                                                           NULL,                                                           NULL,                                                           DecrementDeftemplateBusyCount,                                                           IncrementDeftemplateBusyCount,                                                           NULL,NULL,NULL,NULL };   AllocateEnvironmentData(theEnv,DEFTEMPLATE_DATA,sizeof(struct deftemplateData),DeallocateDeftemplateData);   memcpy(&DeftemplateData(theEnv)->DeftemplatePtrRecord,&deftemplatePtrRecord,sizeof(struct entityRecord));      InitializeFacts(theEnv);   InitializeDeftemplateModules(theEnv);   DeftemplateBasicCommands(theEnv);   DeftemplateFunctions(theEnv);   DeftemplateData(theEnv)->DeftemplateConstruct =      AddConstruct(theEnv,"deftemplate","deftemplates",ParseDeftemplate,EnvFindDeftemplate,                   GetConstructNamePointer,GetConstructPPForm,                   GetConstructModuleItem,EnvGetNextDeftemplate,SetNextConstruct,                   EnvIsDeftemplateDeletable,EnvUndeftemplate,ReturnDeftemplate);   InstallPrimitive(theEnv,(ENTITY_RECORD_PTR) &DeftemplateData(theEnv)->DeftemplatePtrRecord,DEFTEMPLATE_PTR);  }

globle void InitializeAgenda(    void *theEnv){    AllocateEnvironmentData(theEnv,AGENDA_DATA,sizeof(struct agendaData),NULL);    AgendaData(theEnv)->SalienceEvaluation = WHEN_DEFINED;    AgendaData(theEnv)->Strategy = DEFAULT_STRATEGY;    EnvAddClearFunction(theEnv,(char*)"agenda",AgendaClearFunction,0);#if DEBUGGING_FUNCTIONS    AddWatchItem(theEnv,(char*)"activations",1,&AgendaData(theEnv)->WatchActivations,40,DefruleWatchAccess,DefruleWatchPrint);#endif#if ! RUN_TIME    EnvDefineFunction2(theEnv,(char*)"refresh", 'v', PTIEF RefreshCommand, (char*)"RefreshCommand", (char*)"11w");    EnvDefineFunction2(theEnv,(char*)"refresh-agenda",'v',                       PTIEF RefreshAgendaCommand,                       (char*)"RefreshAgendaCommand",                       (char*)"01w");    EnvDefineFunction2(theEnv,(char*)"get-salience-evaluation",'w',                       PTIEF GetSalienceEvaluationCommand,                       (char*)"GetSalienceEvaluationCommand",                       (char*)"00");    EnvDefineFunction2(theEnv,(char*)"set-salience-evaluation",'w',                       PTIEF SetSalienceEvaluationCommand,                       (char*)"SetSalienceEvaluationCommand",                       (char*)"11w");#if DEBUGGING_FUNCTIONS    EnvDefineFunction2(theEnv,(char*)"agenda", 'v', PTIEF AgendaCommand, (char*)"AgendaCommand", (char*)"01w");#endif#endif}

globle void BasicMathFunctionDefinitions(  void *theEnv)  {      AllocateEnvironmentData(theEnv,BMATHFUN_DATA,sizeof(struct basicMathFunctionData),NULL);      BasicMathFunctionData(theEnv)->AutoFloatDividend = TRUE;#if ! RUN_TIME   EnvDefineFunction2(theEnv,"+", 'n',PTIEF AdditionFunction, "AdditionFunction", "2*n");   EnvDefineFunction2(theEnv,"*", 'n', PTIEF MultiplicationFunction, "MultiplicationFunction", "2*n");   EnvDefineFunction2(theEnv,"-", 'n', PTIEF SubtractionFunction, "SubtractionFunction", "2*n");       EnvDefineFunction2(theEnv,"/", 'n', PTIEF DivisionFunction, "DivisionFunction", "2*n");   EnvDefineFunction2(theEnv,"div", 'l', PTIEF DivFunction, "DivFunction", "2*n");   EnvDefineFunction2(theEnv,"set-auto-float-dividend", 'b',                   SetAutoFloatDividendCommand, "SetAutoFloatDividendCommand", "11");   EnvDefineFunction2(theEnv,"get-auto-float-dividend", 'b',                  GetAutoFloatDividendCommand, "GetAutoFloatDividendCommand", "00");   EnvDefineFunction2(theEnv,"integer", 'l', PTIEF IntegerFunction, "IntegerFunction", "11n");   EnvDefineFunction2(theEnv,"float", 'd', PTIEF FloatFunction, "FloatFunction", "11n");   EnvDefineFunction2(theEnv,"abs", 'n', PTIEF AbsFunction, "AbsFunction", "11n");   EnvDefineFunction2(theEnv,"min", 'n', PTIEF MinFunction, "MinFunction", "2*n");   EnvDefineFunction2(theEnv,"max", 'n', PTIEF MaxFunction, "MaxFunction", "2*n");#endif  }

globle void FileCommandDefinitions(  void *theEnv)  {   AllocateEnvironmentData(theEnv,FILECOM_DATA,sizeof(struct fileCommandData),DeallocateFileCommandData);#if ! RUN_TIME#if DEBUGGING_FUNCTIONS   EnvDefineFunction2(theEnv,"batch",'b',PTIEF BatchCommand,"BatchCommand","11k");   EnvDefineFunction2(theEnv,"batch*",'b',PTIEF BatchStarCommand,"BatchStarCommand","11k");   EnvDefineFunction2(theEnv,"dribble-on",'b',PTIEF DribbleOnCommand,"DribbleOnCommand","11k");   EnvDefineFunction2(theEnv,"dribble-off",'b',PTIEF DribbleOffCommand,"DribbleOffCommand","00");   EnvDefineFunction2(theEnv,"save",'b',PTIEF SaveCommand,"SaveCommand","11k");#endif   EnvDefineFunction2(theEnv,"load",'b',PTIEF LoadCommand,"LoadCommand","11k");   EnvDefineFunction2(theEnv,"load*",'b',PTIEF LoadStarCommand,"LoadStarCommand","11k");#if BLOAD_AND_BSAVE   InitializeBsaveData(theEnv);   EnvDefineFunction2(theEnv,"bsave",'b', PTIEF BsaveCommand,"BsaveCommand","11k");#endif#if BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE   InitializeBloadData(theEnv);   EnvDefineFunction2(theEnv,"bload",'b',PTIEF BloadCommand,"BloadCommand","11k");#endif#endif  }

void InitializeConstraints(  Environment *theEnv)  {#if (! RUN_TIME) && (! BLOAD_ONLY)   int i;#endif   AllocateEnvironmentData(theEnv,CONSTRAINT_DATA,sizeof(struct constraintData),DeallocateConstraintData);#if (! RUN_TIME) && (! BLOAD_ONLY)    ConstraintData(theEnv)->ConstraintHashtable = (struct constraintRecord **)                          gm2(theEnv,sizeof (struct constraintRecord *) *                                    SIZE_CONSTRAINT_HASH);    if (ConstraintData(theEnv)->ConstraintHashtable == NULL) ExitRouter(theEnv,EXIT_FAILURE);    for (i = 0; i < SIZE_CONSTRAINT_HASH; i++) ConstraintData(theEnv)->ConstraintHashtable[i] = NULL;#endif#if (! RUN_TIME)   AddUDF(theEnv,"get-dynamic-constraint-checking","b",0,0,NULL,GDCCommand,"GDCCommand",NULL);   AddUDF(theEnv,"set-dynamic-constraint-checking","b",1,1,NULL,SDCCommand,"SDCCommand",NULL);#endif  }

globle void AllocateDefmoduleGlobals(  void *theEnv)  {   AllocateEnvironmentData(theEnv,DEFMODULE_DATA,sizeof(struct defmoduleData),NULL);   AddEnvironmentCleanupFunction(theEnv,"defmodules",DeallocateDefmoduleData,-1000);   DefmoduleData(theEnv)->CallModuleChangeFunctions = TRUE;   DefmoduleData(theEnv)->MainModuleRedefinable = TRUE;  }

globle void SortFunctionDefinitions(  void *theEnv)  {   AllocateEnvironmentData(theEnv,SORTFUN_DATA,sizeof(struct sortFunctionData),DeallocateSortFunctionData);#if ! RUN_TIME   EnvDefineFunction2(theEnv,"sort",'u', PTIEF SortFunction,"SortFunction","1**w");#endif  }

globle void InitializePatterns(  void *theEnv)  {      AllocateEnvironmentData(theEnv,PATTERN_DATA,sizeof(struct patternData),DeallocatePatternData);   PatternData(theEnv)->NextPosition = 1;   PatternData(theEnv)->PatternHashTable = CreatePatternHashTable(theEnv,SIZE_PATTERN_HASH);   PatternData(theEnv)->PatternHashTableSize = SIZE_PATTERN_HASH;  }

globle void InitializePrettyPrintData(  void *theEnv,  EXEC_STATUS)  {   AllocateEnvironmentData(theEnv,execStatus,PRETTY_PRINT_DATA,sizeof(struct prettyPrintData),DeallocatePrettyPrintData);      PrettyPrintData(theEnv,execStatus)->PPBufferEnabled = TRUE;  }

void InitializeStringRouter(  Environment *theEnv)  {   AllocateEnvironmentData(theEnv,STRING_ROUTER_DATA,sizeof(struct stringRouterData),DeallocateStringRouterData);   AddRouter(theEnv,"string",0,QueryStringCallback,WriteStringCallback,ReadStringCallback,UnreadStringCallback,NULL,NULL);   AddRouter(theEnv,"stringBuilder",0,QueryStringBuilderCallback,WriteStringBuilderCallback,NULL,NULL,NULL,NULL);  }

globle void InitializeBloadData(  void *theEnv)  {   AllocateEnvironmentData(theEnv,BLOAD_DATA,sizeof(struct bloadData),NULL);   AddEnvironmentCleanupFunction(theEnv,"bload",DeallocateBloadData,-1500);   BloadData(theEnv)->BinaryPrefixID = "/1/2/3/4CLIPS";   BloadData(theEnv)->BinaryVersionID = "V6.20";  }

globle void InitializeEvaluationData(  void *theEnv)  {   struct externalAddressType cPointer = { "C", PrintCAddress, PrintCAddress, NULL, NewCAddress, NULL };      AllocateEnvironmentData(theEnv,EVALUATION_DATA,sizeof(struct evaluationData),DeallocateEvaluationData);   InstallExternalAddressType(theEnv,&cPointer);  }

globle void InitializeFileRouter(  void *theEnv)  {   AllocateEnvironmentData(theEnv,FILE_ROUTER_DATA,sizeof(struct fileRouterData),DeallocateFileRouterData);   EnvAddRouter(theEnv,"fileio",0,FindFile,             PrintFile,GetcFile,             UngetcFile,ExitFile);  }

globle void InitializeConstructData(  void *theEnv)  {   AllocateEnvironmentData(theEnv,CONSTRUCT_DATA,sizeof(struct constructData),DeallocateConstructData);#if (! RUN_TIME) && (! BLOAD_ONLY)      ConstructData(theEnv)->WatchCompilations = ON;#endif  }

globle void ParseFunctionDefinitions(  void *theEnv)  {   AllocateEnvironmentData(theEnv,PARSEFUN_DATA,sizeof(struct parseFunctionData),NULL);#if ! RUN_TIME   EnvDefineFunction2(theEnv,"check-syntax",'u',PTIEF CheckSyntaxFunction,"CheckSyntaxFunction","11s");#endif  }

void InitializeCommandLineData(  void *theEnv)  {   AllocateEnvironmentData(theEnv,COMMANDLINE_DATA,sizeof(struct commandLineData),DeallocateCommandLineData);#if ! RUN_TIME      CommandLineData(theEnv)->BannerString = BANNER_STRING;   CommandLineData(theEnv)->EventFunction = DefaultGetNextEvent;#endif  }

globle void InitializeEngine(  void *theEnv)  {      AllocateEnvironmentData(theEnv,ENGINE_DATA,sizeof(struct engineData),DeallocateEngineData);   EngineData(theEnv)->IncrementalResetFlag = TRUE;   #if DEBUGGING_FUNCTIONS   AddWatchItem(theEnv,"statistics",0,&EngineData(theEnv)->WatchStatistics,20,NULL,NULL);   AddWatchItem(theEnv,"focus",0,&EngineData(theEnv)->WatchFocus,0,NULL,NULL);#endif  }

globle void InitializeDefaultRouters(  void *theEnv)  {   AllocateEnvironmentData(theEnv,ROUTER_DATA,sizeof(struct routerData),DeallocateRouterData);   RouterData(theEnv)->CommandBufferInputCount = -1;   #if (! RUN_TIME)   EnvDefineFunction2(theEnv,"exit",    'v', PTIEF ExitCommand,    "ExitCommand", "*1i");#endif   InitializeFileRouter(theEnv);   InitializeStringRouter(theEnv);  }

/**********************************************************  NAME         : SetupObjectSystem  DESCRIPTION  : Initializes all COOL constructs, functions,                   and data structures  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : COOL initialized  NOTES        : Order of setup calls is important **********************************************************/globle void SetupObjectSystem(    void *theEnv){    ENTITY_RECORD defclassEntityRecord = { (char*)"DEFCLASS_PTR", DEFCLASS_PTR,1,0,0,                                           NULL,NULL,NULL,NULL,NULL,                                           DecrementDefclassBusyCount,                                           IncrementDefclassBusyCount,                                           NULL,NULL,NULL,NULL,NULL                                         };    AllocateEnvironmentData(theEnv,DEFCLASS_DATA,sizeof(struct defclassData),NULL);    AddEnvironmentCleanupFunction(theEnv,(char*)"defclasses",DeallocateDefclassData,-500);    memcpy(&DefclassData(theEnv)->DefclassEntityRecord,&defclassEntityRecord,sizeof(struct entityRecord));#if ! RUN_TIME    DefclassData(theEnv)->ClassDefaultsMode = CONVENIENCE_MODE;    DefclassData(theEnv)->ISA_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,SUPERCLASS_RLN);    IncrementSymbolCount(DefclassData(theEnv)->ISA_SYMBOL);    DefclassData(theEnv)->NAME_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,NAME_RLN);    IncrementSymbolCount(DefclassData(theEnv)->NAME_SYMBOL);#if DEFRULE_CONSTRUCT    DefclassData(theEnv)->INITIAL_OBJECT_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,INITIAL_OBJECT_NAME);    IncrementSymbolCount(DefclassData(theEnv)->INITIAL_OBJECT_SYMBOL);#endif#endif    SetupDefclasses(theEnv);    SetupInstances(theEnv);    SetupMessageHandlers(theEnv);#if DEFINSTANCES_CONSTRUCT    SetupDefinstances(theEnv);#endif#if INSTANCE_SET_QUERIES    SetupQuery(theEnv);#endif#if BLOAD_AND_BSAVE || BLOAD || BLOAD_ONLY    SetupObjectsBload(theEnv);#endif#if CONSTRUCT_COMPILER && (! RUN_TIME)    SetupObjectsCompiler(theEnv);#endif#if DEFRULE_CONSTRUCT    SetupObjectPatternStuff(theEnv);#endif}

void InitializeDefaultRouters(  void *theEnv)  {   AllocateEnvironmentData(theEnv,ROUTER_DATA,sizeof(struct routerData),DeallocateRouterData);   RouterData(theEnv)->CommandBufferInputCount = 0;   RouterData(theEnv)->AwaitingInput = true;   #if (! RUN_TIME)   EnvAddUDF(theEnv,"exit",   "v", ExitCommand,    "ExitCommand", 0,1,"l",NULL);#endif   InitializeFileRouter(theEnv);   InitializeStringRouter(theEnv);  }

globle void InitializeUtilityData(  void *theEnv)  {   AllocateEnvironmentData(theEnv,UTILITY_DATA,sizeof(struct utilityData),DeallocateUtilityData);      UtilityData(theEnv)->GarbageCollectionLocks = 0;   UtilityData(theEnv)->GarbageCollectionHeuristicsEnabled = TRUE;   UtilityData(theEnv)->PeriodicFunctionsEnabled = TRUE;   UtilityData(theEnv)->YieldFunctionEnabled = TRUE;   UtilityData(theEnv)->CurrentEphemeralCountMax = MAX_EPHEMERAL_COUNT;   UtilityData(theEnv)->CurrentEphemeralSizeMax = MAX_EPHEMERAL_SIZE;   UtilityData(theEnv)->LastEvaluationDepth = -1;  }

globle void InitializeDeffacts(    void *theEnv)  {   AllocateEnvironmentData(theEnv,DEFFACTS_DATA,sizeof(struct deffactsData),DeallocateDeffactsData);     InitializeDeffactsModules(theEnv);   DeffactsBasicCommands(theEnv);   DeffactsData(theEnv)->DeffactsConstruct =      AddConstruct(theEnv,"deffacts","deffacts",ParseDeffacts,EnvFindDeffacts,                   GetConstructNamePointer,GetConstructPPForm,                   GetConstructModuleItem,EnvGetNextDeffacts,SetNextConstruct,                   EnvIsDeffactsDeletable,EnvUndeffacts,ReturnDeffacts);  }

/***********************************************************  NAME         : SetupDeffunctionsBload  DESCRIPTION  : Initializes data structures and                   routines for binary loads of deffunctions  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Routines defined and structures initialized  NOTES        : None ***********************************************************/globle void SetupDeffunctionsBload(    void *theEnv){    AllocateEnvironmentData(theEnv,DFFNXBIN_DATA,sizeof(struct deffunctionBinaryData),DeallocateDeffunctionBloadData);#if BLOAD_AND_BSAVE    AddBinaryItem(theEnv,"deffunctions",0,BsaveDeffunctionFind,BsaveDeffunctionExpressions,                  BsaveStorageDeffunctions,BsaveDeffunctions,                  BloadStorageDeffunctions,BloadDeffunctions,                  ClearDeffunctionBload);#else    AddBinaryItem(theEnv,"deffunctions",0,NULL,NULL,NULL,NULL,                  BloadStorageDeffunctions,BloadDeffunctions,                  ClearDeffunctionBload);#endif}