/*******************************************************************************
NAME : PPDefmessageHandlerCommand
DESCRIPTION : Displays the pretty-print form (if any) for a handler
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : None
NOTES : H/L Syntax: (ppdefmessage-handler <class> <message> [<type>])
*******************************************************************************/
globle void PPDefmessageHandlerCommand(
void *theEnv)
{
DATA_OBJECT temp;
SYMBOL_HN *csym,*msym;
const char *tname;
DEFCLASS *cls = NULL;
unsigned mtype;
HANDLER *hnd;
if (EnvArgTypeCheck(theEnv,"ppdefmessage-handler",1,SYMBOL,&temp) == FALSE)
return;
csym = FindSymbolHN(theEnv,DOToString(temp));
if (EnvArgTypeCheck(theEnv,"ppdefmessage-handler",2,SYMBOL,&temp) == FALSE)
return;
msym = FindSymbolHN(theEnv,DOToString(temp));
if (EnvRtnArgCount(theEnv) == 3)
{
if (EnvArgTypeCheck(theEnv,"ppdefmessage-handler",3,SYMBOL,&temp) == FALSE)
return;
tname = DOToString(temp);
}
else
tname = MessageHandlerData(theEnv)->hndquals[MPRIMARY];
mtype = HandlerType(theEnv,"ppdefmessage-handler",tname);
if (mtype == MERROR)
{
EnvSetEvaluationError(theEnv,TRUE);
return;
}
if (csym != NULL)
cls = LookupDefclassByMdlOrScope(theEnv,ValueToString(csym));
if (((cls == NULL) || (msym == NULL)) ? TRUE :
((hnd = FindHandlerByAddress(cls,msym,(unsigned) mtype)) == NULL))
{
PrintErrorID(theEnv,"MSGCOM",2,FALSE);
EnvPrintRouter(theEnv,WERROR,"Unable to find message-handler ");
EnvPrintRouter(theEnv,WERROR,ValueToString(msym));
EnvPrintRouter(theEnv,WERROR," ");
EnvPrintRouter(theEnv,WERROR,tname);
EnvPrintRouter(theEnv,WERROR," for class ");
EnvPrintRouter(theEnv,WERROR,ValueToString(csym));
EnvPrintRouter(theEnv,WERROR," in function ppdefmessage-handler.\n");
EnvSetEvaluationError(theEnv,TRUE);
return;
}
if (hnd->ppForm != NULL)
PrintInChunks(theEnv,WDISPLAY,hnd->ppForm);
}
/***************************************************
NAME : LookupDefclassByMdlOrScope
DESCRIPTION : Finds a class anywhere (if module
is specified) or in current or
imported modules
INPUTS : The class name
RETURNS : The class (NULL if not found)
SIDE EFFECTS : Error message printed on
ambiguous references
NOTES : Assumes no two classes of the same
name are ever in the same scope
***************************************************/
globle DEFCLASS *LookupDefclassByMdlOrScope(
void *theEnv,
const char *classAndModuleName)
{
DEFCLASS *cls;
const char *className;
SYMBOL_HN *classSymbol;
struct defmodule *theModule;
if (FindModuleSeparator(classAndModuleName) == FALSE)
return(LookupDefclassInScope(theEnv,classAndModuleName));
SaveCurrentModule(theEnv);
className = ExtractModuleAndConstructName(theEnv,classAndModuleName);
theModule = ((struct defmodule *) EnvGetCurrentModule(theEnv));
RestoreCurrentModule(theEnv);
if(className == NULL)
return(NULL);
if ((classSymbol = FindSymbolHN(theEnv,className)) == NULL)
return(NULL);
cls = DefclassData(theEnv)->ClassTable[HashClass(classSymbol)];
while (cls != NULL)
{
if ((cls->header.name == classSymbol) &&
(cls->header.whichModule->theModule == theModule))
return(cls->installed ? cls : NULL);
cls = cls->nxtHash;
}
return(NULL);
}
/*********************************************************
NAME : SlotInfoSlot
DESCRIPTION : Runtime support routine for slot-sources,
slot-facets, et. al. which looks up
a slot
INPUTS : 1) Data object buffer
2) Class pointer
3) Name-string of slot to find
4) The name of the calling function
RETURNS : Nothing useful
SIDE EFFECTS : Support function called and data object
buffer initialized
NOTES : None
*********************************************************/
static SLOT_DESC *SlotInfoSlot(
void *theEnv,
DATA_OBJECT *result,
DEFCLASS *cls,
const char *sname,
const char *fnxname)
{
SYMBOL_HN *ssym;
int i;
if ((ssym = FindSymbolHN(theEnv,sname)) == NULL)
{
SetEvaluationError(theEnv,TRUE);
EnvSetMultifieldErrorValue(theEnv,result);
return(NULL);
}
i = FindInstanceTemplateSlot(theEnv,cls,ssym);
if (i == -1)
{
SlotExistError(theEnv,sname,fnxname);
SetEvaluationError(theEnv,TRUE);
EnvSetMultifieldErrorValue(theEnv,result);
return(NULL);
}
result->type = MULTIFIELD;
result->begin = 0;
return(cls->instanceTemplate[i]);
}
globle intBool ConstructExported(
void *theEnv,
EXEC_STATUS,
char *constructTypeStr,
struct symbolHashNode *moduleName,
struct symbolHashNode *findName)
{
struct symbolHashNode *constructType;
struct defmodule *theModule;
struct portItem *theExportList;
constructType = FindSymbolHN(theEnv,execStatus,constructTypeStr);
theModule = (struct defmodule *) EnvFindDefmodule(theEnv,execStatus,ValueToString(moduleName));
if ((constructType == NULL) || (theModule == NULL) || (findName == NULL))
{ return(FALSE); }
theExportList = theModule->exportList;
while (theExportList != NULL)
{
if ((theExportList->constructType == NULL) ||
(theExportList->constructType == constructType))
{
if ((theExportList->constructName == NULL) ||
(theExportList->constructName == findName))
{ return TRUE; }
}
theExportList = theExportList->next;
}
return FALSE;
}
globle void *GensymStar(
void *theEnv)
{
char genstring[15];
/*=======================================================*/
/* Create a symbol using the current gensym index as the */
/* postfix. If the symbol is already present in the */
/* symbol table, then continue generating symbols until */
/* a unique symbol is found. */
/*=======================================================*/
do
{
sprintf(genstring,"gen%ld",MiscFunctionData(theEnv)->GensymNumber);
MiscFunctionData(theEnv)->GensymNumber++;
}
while (FindSymbolHN(theEnv,genstring) != NULL);
/*====================*/
/* Return the symbol. */
/*====================*/
return(EnvAddSymbol(theEnv,genstring));
}
globle int UndefineFunction(
void *theEnv,
const char *functionName)
{
SYMBOL_HN *findValue;
struct FunctionDefinition *fPtr, *lastPtr = NULL;
findValue = (SYMBOL_HN *) FindSymbolHN(theEnv,functionName);
for (fPtr = ExternalFunctionData(theEnv)->ListOfFunctions;
fPtr != NULL;
fPtr = fPtr->next)
{
if (fPtr->callFunctionName == findValue)
{
DecrementSymbolCount(theEnv,fPtr->callFunctionName);
RemoveHashFunction(theEnv,fPtr);
if (lastPtr == NULL)
{ ExternalFunctionData(theEnv)->ListOfFunctions = fPtr->next; }
else
{ lastPtr->next = fPtr->next; }
ClearUserDataList(theEnv,fPtr->usrData);
rtn_struct(theEnv,FunctionDefinition,fPtr);
return(TRUE);
}
lastPtr = fPtr;
}
return(FALSE);
}
/*******************************************************************
NAME : EnvFindDefclass
DESCRIPTION : Looks up a specified class in the class hash table
(Only looks in current or specified module)
INPUTS : The name-string of the class (including module)
RETURNS : The address of the found class, NULL otherwise
SIDE EFFECTS : None
NOTES : None
******************************************************************/
globle void *EnvFindDefclass( // TBD Needs to look in imported
void *theEnv,
const char *classAndModuleName)
{
SYMBOL_HN *classSymbol = NULL;
DEFCLASS *cls;
struct defmodule *theModule = NULL;
const char *className;
SaveCurrentModule(theEnv);
className = ExtractModuleAndConstructName(theEnv,classAndModuleName);
if (className != NULL)
{
classSymbol = FindSymbolHN(theEnv,ExtractModuleAndConstructName(theEnv,classAndModuleName));
theModule = ((struct defmodule *) EnvGetCurrentModule(theEnv));
}
RestoreCurrentModule(theEnv);
if (classSymbol == NULL)
return(NULL);
cls = DefclassData(theEnv)->ClassTable[HashClass(classSymbol)];
while (cls != NULL)
{
if (cls->header.name == classSymbol)
{
if (cls->system || (cls->header.whichModule->theModule == theModule))
return(cls->installed ? (void *) cls : NULL);
}
cls = cls->nxtHash;
}
return(NULL);
}
/****************************************************
NAME : LookupDefclassInScope
DESCRIPTION : Finds a class in current or imported
modules (module specifier
is not allowed)
INPUTS : The class name
RETURNS : The class (NULL if not found)
SIDE EFFECTS : Error message printed on
ambiguous references
NOTES : Assumes no two classes of the same
name are ever in the same scope
****************************************************/
globle DEFCLASS *LookupDefclassInScope(
void *theEnv,
const char *className)
{
DEFCLASS *cls;
SYMBOL_HN *classSymbol;
if ((classSymbol = FindSymbolHN(theEnv,className)) == NULL)
return(NULL);
cls = DefclassData(theEnv)->ClassTable[HashClass(classSymbol)];
while (cls != NULL)
{
if ((cls->header.name == classSymbol) && DefclassInScope(theEnv,cls,NULL))
return(cls->installed ? cls : NULL);
cls = cls->nxtHash;
}
return(NULL);
}
/****************************************************
NAME : SetupFactQuery
DESCRIPTION : Initializes fact query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
globle void SetupFactQuery(
void *theEnv)
{
AllocateEnvironmentData(theEnv,FACT_QUERY_DATA,sizeof(struct factQueryData),NULL);
#if RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMETER_STRING);
#endif
#if ! RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,QUERY_DELIMETER_STRING);
IncrementSymbolCount(FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL);
EnvDefineFunction2(theEnv,"(query-fact)",'u',
PTIEF GetQueryFact,"GetQueryFact",NULL);
EnvDefineFunction2(theEnv,"(query-fact-slot)",'u',
PTIEF GetQueryFactSlot,"GetQueryFactSlot",NULL);
EnvDefineFunction2(theEnv,"any-factp",'b',PTIEF AnyFacts,"AnyFacts",NULL);
AddFunctionParser(theEnv,"any-factp",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"find-fact",'m',
PTIEF QueryFindFact,"QueryFindFact",NULL);
AddFunctionParser(theEnv,"find-fact",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"find-all-facts",'m',
PTIEF QueryFindAllFacts,"QueryFindAllFacts",NULL);
AddFunctionParser(theEnv,"find-all-facts",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"do-for-fact",'u',
PTIEF QueryDoForFact,"QueryDoForFact",NULL);
AddFunctionParser(theEnv,"do-for-fact",FactParseQueryAction);
EnvDefineFunction2(theEnv,"do-for-all-facts",'u',
PTIEF QueryDoForAllFacts,"QueryDoForAllFacts",NULL);
AddFunctionParser(theEnv,"do-for-all-facts",FactParseQueryAction);
EnvDefineFunction2(theEnv,"delayed-do-for-all-facts",'u',
PTIEF DelayedQueryDoForAllFacts,
"DelayedQueryDoForAllFacts",NULL);
AddFunctionParser(theEnv,"delayed-do-for-all-facts",FactParseQueryAction);
#endif
}
/********************************************************************
NAME : EnvPreviewSend
DESCRIPTION : Displays a list of the core for a message describing
shadows,etc.
INPUTS : 1) Logical name of output
2) Class pointer
3) Message name-string
RETURNS : Nothing useful
SIDE EFFECTS : Temporary core created and destroyed
NOTES : None
********************************************************************/
globle void EnvPreviewSend(
void *theEnv,
const char *logicalName,
void *clsptr,
const char *msgname)
{
HANDLER_LINK *core;
SYMBOL_HN *msym;
msym = FindSymbolHN(theEnv,msgname);
if (msym == NULL)
return;
core = FindPreviewApplicableHandlers(theEnv,(DEFCLASS *) clsptr,msym);
if (core != NULL)
{
DisplayCore(theEnv,logicalName,core,0);
DestroyHandlerLinks(theEnv,core);
}
}
Defmodule *FindDefmodule(
Environment *theEnv,
const char *defmoduleName)
{
Defmodule *defmodulePtr;
CLIPSLexeme *findValue;
if ((findValue = FindSymbolHN(theEnv,defmoduleName,SYMBOL_BIT)) == NULL) return NULL;
defmodulePtr = DefmoduleData(theEnv)->ListOfDefmodules;
while (defmodulePtr != NULL)
{
if (defmodulePtr->header.name == findValue)
{ return defmodulePtr; }
defmodulePtr = (Defmodule *) defmodulePtr->header.next;
}
return NULL;
}
globle void *EnvFindDefmodule(
void *theEnv,
char *defmoduleName)
{
struct defmodule *defmodulePtr;
SYMBOL_HN *findValue;
if ((findValue = (SYMBOL_HN *) FindSymbolHN(theEnv,defmoduleName)) == NULL) return(NULL);
defmodulePtr = DefmoduleData(theEnv)->ListOfDefmodules;
while (defmodulePtr != NULL)
{
if (defmodulePtr->name == findValue)
{ return((void *) defmodulePtr); }
defmodulePtr = defmodulePtr->next;
}
return(NULL);
}
/******************************************************
NAME : LookupDefclassAnywhere
DESCRIPTION : Finds a class in specified
(or any) module
INPUTS : 1) The module (NULL if don't care)
2) The class name (module specifier
in name not allowed)
RETURNS : The class (NULL if not found)
SIDE EFFECTS : None
NOTES : Does *not* generate an error if
multiple classes of the same name
exist as do the other lookup functions
******************************************************/
globle DEFCLASS *LookupDefclassAnywhere(
void *theEnv,
struct defmodule *theModule,
const char *className)
{
DEFCLASS *cls;
SYMBOL_HN *classSymbol;
if ((classSymbol = FindSymbolHN(theEnv,className)) == NULL)
return(NULL);
cls = DefclassData(theEnv)->ClassTable[HashClass(classSymbol)];
while (cls != NULL)
{
if ((cls->header.name == classSymbol) &&
((theModule == NULL) ||
(cls->header.whichModule->theModule == theModule)))
return(cls->installed ? cls : NULL);
cls = cls->nxtHash;
}
return(NULL);
}
/***************************************************
NAME : LookupSlot
DESCRIPTION : Finds a slot in a class
INPUTS : 1) The class
2) The slot name
3) A flag indicating if inherited
slots are OK or not
RETURNS : The slot descriptor address, or
NULL if not found
SIDE EFFECTS : None
NOTES : None
***************************************************/
static SLOT_DESC *LookupSlot(
void *theEnv,
DEFCLASS *theDefclass,
char *slotName,
intBool inheritFlag)
{
SYMBOL_HN *slotSymbol;
int slotIndex;
SLOT_DESC *sd;
slotSymbol = FindSymbolHN(theEnv,slotName);
if (slotSymbol == NULL)
return(NULL);
slotIndex = FindInstanceTemplateSlot(theEnv,theDefclass,slotSymbol);
if (slotIndex == -1)
return(NULL);
sd = theDefclass->instanceTemplate[slotIndex];
if ((sd->cls != theDefclass) && (inheritFlag == FALSE))
return(NULL);
return(sd);
}
/***************************************************
NAME : EnvFindDefmessageHandler
DESCRIPTION : Determines the index of a specfied
message-handler
INPUTS : 1) A pointer to the class
2) Name-string of the handler
3) Handler-type: "around","before",
"primary", or "after"
RETURNS : The index of the handler
(0 if not found)
SIDE EFFECTS : None
NOTES : None
***************************************************/
globle unsigned EnvFindDefmessageHandler(
void *theEnv,
void *ptr,
const char *hname,
const char *htypestr)
{
unsigned htype;
SYMBOL_HN *hsym;
DEFCLASS *cls;
int theIndex;
htype = HandlerType(theEnv,"handler-lookup",htypestr);
if (htype == MERROR)
return(0);
hsym = FindSymbolHN(theEnv,hname);
if (hsym == NULL)
return(0);
cls = (DEFCLASS *) ptr;
theIndex = FindHandlerByIndex(cls,hsym,(unsigned) htype);
return((unsigned) (theIndex+1));
}
/****************************************************
NAME : SetupFactQuery
DESCRIPTION : Initializes fact query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
void SetupFactQuery(
Environment *theEnv)
{
AllocateEnvironmentData(theEnv,FACT_QUERY_DATA,sizeof(struct factQueryData),NULL);
#if RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMITER_STRING,SYMBOL_BIT);
#endif
#if ! RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL = CreateSymbol(theEnv,QUERY_DELIMITER_STRING);
IncrementLexemeCount(FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL);
AddUDF(theEnv,"(query-fact)","f",0,UNBOUNDED,NULL,GetQueryFact,"GetQueryFact",NULL);
AddUDF(theEnv,"(query-fact-slot)","*",0,UNBOUNDED,NULL,GetQueryFactSlot,"GetQueryFactSlot",NULL);
AddUDF(theEnv,"any-factp","b",0,UNBOUNDED,NULL,AnyFacts,"AnyFacts",NULL);
AddUDF(theEnv,"find-fact","m",0,UNBOUNDED,NULL,QueryFindFact,"QueryFindFact",NULL);
AddUDF(theEnv,"find-all-facts","m",0,UNBOUNDED,NULL,QueryFindAllFacts,"QueryFindAllFacts",NULL);
AddUDF(theEnv,"do-for-fact","*",0,UNBOUNDED,NULL,QueryDoForFact,"QueryDoForFact",NULL);
AddUDF(theEnv,"do-for-all-facts","*",0,UNBOUNDED,NULL,QueryDoForAllFacts,"QueryDoForAllFacts",NULL);
AddUDF(theEnv,"delayed-do-for-all-facts","*",0,UNBOUNDED,NULL,DelayedQueryDoForAllFacts,"DelayedQueryDoForAllFacts",NULL);
#endif
AddFunctionParser(theEnv,"any-factp",FactParseQueryNoAction);
AddFunctionParser(theEnv,"find-fact",FactParseQueryNoAction);
AddFunctionParser(theEnv,"find-all-facts",FactParseQueryNoAction);
AddFunctionParser(theEnv,"do-for-fact",FactParseQueryAction);
AddFunctionParser(theEnv,"do-for-all-facts",FactParseQueryAction);
AddFunctionParser(theEnv,"delayed-do-for-all-facts",FactParseQueryAction);
}
globle struct FunctionDefinition *FindFunction(
void *theEnv,
const char *functionName)
{
struct FunctionHash *fhPtr;
unsigned hashValue;
SYMBOL_HN *findValue;
if (ExternalFunctionData(theEnv)->FunctionHashtable == NULL) return(NULL);
hashValue = HashSymbol(functionName,SIZE_FUNCTION_HASH);
findValue = (SYMBOL_HN *) FindSymbolHN(theEnv,functionName);
for (fhPtr = ExternalFunctionData(theEnv)->FunctionHashtable[hashValue];
fhPtr != NULL;
fhPtr = fhPtr->next)
{
if (fhPtr->fdPtr->callFunctionName == findValue)
{ return(fhPtr->fdPtr); }
}
return(NULL);
}
/***************************************************
NAME : LookupSlot
DESCRIPTION : Finds a slot in a class
INPUTS : 1) The class
2) The slot name
3) A flag indicating if inherited
slots are OK or not
RETURNS : The slot descriptor address, or
NULL if not found
SIDE EFFECTS : None
NOTES : None
***************************************************/
static SlotDescriptor *LookupSlot(
Environment *theEnv,
Defclass *theDefclass,
const char *slotName,
bool inheritFlag)
{
CLIPSLexeme *slotSymbol;
int slotIndex;
SlotDescriptor *sd;
slotSymbol = FindSymbolHN(theEnv,slotName,SYMBOL_BIT);
if (slotSymbol == NULL)
{ return NULL; }
slotIndex = FindInstanceTemplateSlot(theEnv,theDefclass,slotSymbol);
if (slotIndex == -1)
{ return NULL; }
sd = theDefclass->instanceTemplate[slotIndex];
if ((sd->cls != theDefclass) && (inheritFlag == false))
{ return NULL; }
return sd;
}
/***************************************************
NAME : ObjectsRunTimeInitialize
DESCRIPTION : Initializes objects system lists
in a run-time module
INPUTS : 1) Pointer to new class hash table
2) Pointer to new slot name table
RETURNS : Nothing useful
SIDE EFFECTS : Global pointers set
NOTES : None
***************************************************/
globle void ObjectsRunTimeInitialize(
void *theEnv,
DEFCLASS *ctable[],
SLOT_NAME *sntable[],
DEFCLASS **cidmap,
unsigned mid)
{
DEFCLASS *cls;
void *tmpexp;
register unsigned int i,j;
if (DefclassData(theEnv)->ClassTable != NULL)
{
for (j = 0 ; j < CLASS_TABLE_HASH_SIZE ; j++)
for (cls = DefclassData(theEnv)->ClassTable[j] ; cls != NULL ; cls = cls->nxtHash)
{
for (i = 0 ; i < cls->slotCount ; i++)
{
/* =====================================================================
For static default values, the data object value needs to deinstalled
and deallocated, and the expression needs to be restored (which was
temporarily stored in the supplementalInfo field of the data object)
===================================================================== */
if ((cls->slots[i].defaultValue != NULL) && (cls->slots[i].dynamicDefault == 0))
{
tmpexp = ((DATA_OBJECT *) cls->slots[i].defaultValue)->supplementalInfo;
ValueDeinstall(theEnv,(DATA_OBJECT *) cls->slots[i].defaultValue);
rtn_struct(theEnv,dataObject,cls->slots[i].defaultValue);
cls->slots[i].defaultValue = tmpexp;
}
}
}
}
InstanceQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMETER_STRING);
MessageHandlerData(theEnv)->INIT_SYMBOL = FindSymbolHN(theEnv,INIT_STRING);
MessageHandlerData(theEnv)->DELETE_SYMBOL = FindSymbolHN(theEnv,DELETE_STRING);
MessageHandlerData(theEnv)->CREATE_SYMBOL = FindSymbolHN(theEnv,CREATE_STRING);
DefclassData(theEnv)->ISA_SYMBOL = FindSymbolHN(theEnv,SUPERCLASS_RLN);
DefclassData(theEnv)->NAME_SYMBOL = FindSymbolHN(theEnv,NAME_RLN);
#if DEFRULE_CONSTRUCT
DefclassData(theEnv)->INITIAL_OBJECT_SYMBOL = FindSymbolHN(theEnv,INITIAL_OBJECT_NAME);
#endif
DefclassData(theEnv)->ClassTable = (DEFCLASS **) ctable;
DefclassData(theEnv)->SlotNameTable = (SLOT_NAME **) sntable;
DefclassData(theEnv)->ClassIDMap = (DEFCLASS **) cidmap;
DefclassData(theEnv)->MaxClassID = (unsigned short) mid;
DefclassData(theEnv)->PrimitiveClassMap[FLOAT] =
LookupDefclassByMdlOrScope(theEnv,FLOAT_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[INTEGER] =
LookupDefclassByMdlOrScope(theEnv,INTEGER_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[STRING] =
LookupDefclassByMdlOrScope(theEnv,STRING_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[SYMBOL] =
LookupDefclassByMdlOrScope(theEnv,SYMBOL_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[MULTIFIELD] =
LookupDefclassByMdlOrScope(theEnv,MULTIFIELD_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[EXTERNAL_ADDRESS] =
LookupDefclassByMdlOrScope(theEnv,EXTERNAL_ADDRESS_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[FACT_ADDRESS] =
LookupDefclassByMdlOrScope(theEnv,FACT_ADDRESS_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME] =
LookupDefclassByMdlOrScope(theEnv,INSTANCE_NAME_TYPE_NAME);
DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_ADDRESS] =
LookupDefclassByMdlOrScope(theEnv,INSTANCE_ADDRESS_TYPE_NAME);
for (j = 0 ; j < CLASS_TABLE_HASH_SIZE ; j++)
for (cls = DefclassData(theEnv)->ClassTable[j] ; cls != NULL ; cls = cls->nxtHash)
{
for (i = 0 ; i < cls->slotCount ; i++)
{
if ((cls->slots[i].defaultValue != NULL) && (cls->slots[i].dynamicDefault == 0))
{
tmpexp = cls->slots[i].defaultValue;
cls->slots[i].defaultValue = (void *) get_struct(theEnv,dataObject);
EvaluateAndStoreInDataObject(theEnv,(int) cls->slots[i].multiple,(EXPRESSION *) tmpexp,
(DATA_OBJECT *) cls->slots[i].defaultValue,TRUE);
ValueInstall(theEnv,(DATA_OBJECT *) cls->slots[i].defaultValue);
((DATA_OBJECT *) cls->slots[i].defaultValue)->supplementalInfo = tmpexp;
}
}
}
SearchForHashedPatternNodes(theEnv,ObjectReteData(theEnv)->ObjectPatternNetworkPointer);
}
