/***************************************************
NAME : ReplaceTemplateNameWithReference
DESCRIPTION : In parsing an fact-set query,
this function replaces a constant
template name with an actual pointer
to the template
INPUTS : The expression
RETURNS : TRUE if all OK, FALSE
if template cannot be found
SIDE EFFECTS : The expression type and value are
modified if template is found
NOTES : Searches current and imported
modules for reference
***************************************************/
static intBool ReplaceTemplateNameWithReference(
void *theEnv,
EXPRESSION *theExp)
{
const char *theTemplateName;
void *theDeftemplate;
int count;
if (theExp->type == SYMBOL)
{
theTemplateName = ValueToString(theExp->value);
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,theTemplateName,
&count,TRUE,NULL);
if (theDeftemplate == NULL)
{
CantFindItemErrorMessage(theEnv,"deftemplate",theTemplateName);
return(FALSE);
}
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"deftemplate",theTemplateName);
return(FALSE);
}
theExp->type = DEFTEMPLATE_PTR;
theExp->value = theDeftemplate;
}
return(TRUE);
}
/***************************************************
NAME : UpdateDefclassesScope
DESCRIPTION : This function updates the scope
bitmaps for existing classes when
a new module is defined
INPUTS : None
RETURNS : Nothing
SIDE EFFECTS : Class scope bitmaps are updated
NOTES : None
***************************************************/
static void UpdateDefclassesScope(
void *theEnv)
{
register unsigned i;
DEFCLASS *theDefclass;
int newModuleID,count;
char *newScopeMap;
unsigned newScopeMapSize;
char *className;
struct defmodule *matchModule;
newModuleID = (int) ((struct defmodule *) EnvGetCurrentModule(theEnv))->bsaveID;
newScopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
newScopeMap = (char *) gm2(theEnv,newScopeMapSize);
for (i = 0 ; i < CLASS_TABLE_HASH_SIZE ; i++)
for (theDefclass = DefclassData(theEnv)->ClassTable[i] ;
theDefclass != NULL ;
theDefclass = theDefclass->nxtHash)
{
matchModule = theDefclass->header.whichModule->theModule;
className = ValueToString(theDefclass->header.name);
ClearBitString((void *) newScopeMap,newScopeMapSize);
GenCopyMemory(char,theDefclass->scopeMap->size,
newScopeMap,ValueToBitMap(theDefclass->scopeMap));
DecrementBitMapCount(theEnv,theDefclass->scopeMap);
if (theDefclass->system)
SetBitMap(newScopeMap,newModuleID);
else if (FindImportedConstruct(theEnv,(char*)"defclass",matchModule,
className,&count,TRUE,NULL) != NULL)
SetBitMap(newScopeMap,newModuleID);
theDefclass->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) newScopeMap,newScopeMapSize);
IncrementBitMapCount(theDefclass->scopeMap);
}
rm(theEnv,(void *) newScopeMap,newScopeMapSize);
}
globle void *CreateDeftemplateScopeMap(
void *theEnv,
struct deftemplate *theDeftemplate)
{
unsigned scopeMapSize;
char *scopeMap;
char *templateName;
struct defmodule *matchModule, *theModule;
int moduleID,count;
void *theBitMap;
templateName = ValueToString(theDeftemplate->header.name);
matchModule = theDeftemplate->header.whichModule->theModule;
scopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
scopeMap = (char *) gm2(theEnv,scopeMapSize);
ClearBitString((void *) scopeMap,scopeMapSize);
SaveCurrentModule(theEnv);
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL) ;
theModule != NULL ;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleID = (int) theModule->bsaveID;
if (FindImportedConstruct(theEnv,"deftemplate",matchModule,
templateName,&count,TRUE,NULL) != NULL)
SetBitMap(scopeMap,moduleID);
}
RestoreCurrentModule(theEnv);
theBitMap = EnvAddBitMap(theEnv,scopeMap,scopeMapSize);
IncrementBitMapCount(theBitMap);
rm(theEnv,(void *) scopeMap,scopeMapSize);
return(theBitMap);
}
static intBool GetDefglobalValue2(
void *theEnv,
void *theValue,
DATA_OBJECT_PTR vPtr)
{
struct defglobal *theGlobal;
int count;
/*===========================================*/
/* Search for the specified defglobal in the */
/* modules visible to the current module. */
/*===========================================*/
theGlobal = (struct defglobal *)
FindImportedConstruct(theEnv,"defglobal",NULL,ValueToString(theValue),
&count,TRUE,NULL);
/*=============================================*/
/* If it wasn't found, print an error message. */
/*=============================================*/
if (theGlobal == NULL)
{
PrintErrorID(theEnv,"GLOBLDEF",1,FALSE);
EnvPrintRouter(theEnv,WERROR,"Global variable ?*");
EnvPrintRouter(theEnv,WERROR,ValueToString(theValue));
EnvPrintRouter(theEnv,WERROR,"* is unbound.\n");
vPtr->type = SYMBOL;
vPtr->value = EnvFalseSymbol(theEnv);
SetEvaluationError(theEnv,TRUE);
return(FALSE);
}
/*========================================================*/
/* The current implementation of the defmodules shouldn't */
/* allow a construct to be defined which would cause an */
/* ambiguous reference, but we'll check for it anyway. */
/*========================================================*/
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"defglobal",ValueToString(theValue));
vPtr->type = SYMBOL;
vPtr->value = EnvFalseSymbol(theEnv);
SetEvaluationError(theEnv,TRUE);
return(FALSE);
}
/*=================================*/
/* Get the value of the defglobal. */
/*=================================*/
QGetDefglobalValue(theEnv,theGlobal,vPtr);
return(TRUE);
}
static bool EntityGetDefglobalValue(
Environment *theEnv,
void *theValue,
UDFValue *vPtr)
{
Defglobal *theGlobal;
unsigned int count;
/*===========================================*/
/* Search for the specified defglobal in the */
/* modules visible to the current module. */
/*===========================================*/
theGlobal = (Defglobal *)
FindImportedConstruct(theEnv,"defglobal",NULL,((CLIPSLexeme *) theValue)->contents,
&count,true,NULL);
/*=============================================*/
/* If it wasn't found, print an error message. */
/*=============================================*/
if (theGlobal == NULL)
{
PrintErrorID(theEnv,"GLOBLDEF",1,false);
WriteString(theEnv,STDERR,"Global variable ?*");
WriteString(theEnv,STDERR,((CLIPSLexeme *) theValue)->contents);
WriteString(theEnv,STDERR,"* is unbound.\n");
vPtr->value = FalseSymbol(theEnv);
SetEvaluationError(theEnv,true);
return false;
}
/*========================================================*/
/* The current implementation of the defmodules shouldn't */
/* allow a construct to be defined which would cause an */
/* ambiguous reference, but we'll check for it anyway. */
/*========================================================*/
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"defglobal",((CLIPSLexeme *) theValue)->contents);
vPtr->value = FalseSymbol(theEnv);
SetEvaluationError(theEnv,true);
return false;
}
/*=================================*/
/* Get the value of the defglobal. */
/*=================================*/
CLIPSToUDFValue(&theGlobal->current,vPtr);
return true;
}
globle intBool ReplaceGlobalVariable(
void *theEnv,
struct expr *ePtr)
{
struct defglobal *theGlobal;
int count;
/*=================================*/
/* Search for the global variable. */
/*=================================*/
theGlobal = (struct defglobal *)
FindImportedConstruct(theEnv,"defglobal",NULL,ValueToString(ePtr->value),
&count,TRUE,NULL);
/*=============================================*/
/* If it wasn't found, print an error message. */
/*=============================================*/
if (theGlobal == NULL)
{
GlobalReferenceErrorMessage(theEnv,ValueToString(ePtr->value));
return(FALSE);
}
/*========================================================*/
/* The current implementation of the defmodules shouldn't */
/* allow a construct to be defined which would cause an */
/* ambiguous reference, but we'll check for it anyway. */
/*========================================================*/
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"defglobal",ValueToString(ePtr->value));
return(FALSE);
}
/*==============================================*/
/* Replace the symbolic reference of the global */
/* variable with a direct pointer reference. */
/*==============================================*/
ePtr->type = DEFGLOBAL_PTR;
ePtr->value = (void *) theGlobal;
return(TRUE);
}
globle struct lhsParseNode *CreateInitialFactPattern(
void *theEnv)
{
struct lhsParseNode *topNode;
struct deftemplate *theDeftemplate;
int count;
/*==================================*/
/* If the initial-fact deftemplate */
/* doesn't exist, then create it. */
/*==================================*/
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,"initial-fact",
&count,TRUE,NULL);
if (theDeftemplate == NULL)
{
PrintWarningID(theEnv,"FACTLHS",1,FALSE);
EnvPrintRouter(theEnv,WWARNING,"Creating implied initial-fact deftemplate in module ");
EnvPrintRouter(theEnv,WWARNING,EnvGetDefmoduleName(theEnv,EnvGetCurrentModule(theEnv)));
EnvPrintRouter(theEnv,WWARNING,".\n");
EnvPrintRouter(theEnv,WWARNING," You probably want to import this deftemplate from the MAIN module.\n");
CreateImpliedDeftemplate(theEnv,(SYMBOL_HN *) EnvAddSymbol(theEnv,"initial-fact"),FALSE);
}
/*====================================*/
/* Create the (initial-fact) pattern. */
/*====================================*/
topNode = GetLHSParseNode(theEnv);
topNode->type = SF_WILDCARD;
topNode->index = 0;
topNode->slotNumber = 1;
topNode->bottom = GetLHSParseNode(theEnv);
topNode->bottom->type = SYMBOL;
topNode->bottom->value = (void *) EnvAddSymbol(theEnv,"initial-fact");
/*=====================*/
/* Return the pattern. */
/*=====================*/
return(topNode);
}
void UpdateDefglobalScope(
Environment *theEnv)
{
Defglobal *theDefglobal;
unsigned int moduleCount;
Defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*============================*/
/* Loop through every module. */
/*============================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*============================================================*/
/* Loop through every defglobal in the module being examined. */
/*============================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DefglobalData(theEnv)->DefglobalModuleIndex);
for (theDefglobal = (Defglobal *) theItem->firstItem;
theDefglobal != NULL ;
theDefglobal = GetNextDefglobal(theEnv,theDefglobal))
{
/*====================================================*/
/* If the defglobal is visible to the current module, */
/* then mark it as being in scope, otherwise mark it */
/* as being out of scope. */
/*====================================================*/
if (FindImportedConstruct(theEnv,"defglobal",theModule,
theDefglobal->header.name->contents,
&moduleCount,true,NULL) != NULL)
{ theDefglobal->inScope = true; }
else
{ theDefglobal->inScope = false; }
}
}
}
void UpdateDeftemplateScope(
void *theEnv)
{
struct deftemplate *theDeftemplate;
int moduleCount;
struct defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*==================================*/
/* Loop through all of the modules. */
/*==================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
/*======================================================*/
/* Loop through each of the deftemplates in the module. */
/*======================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DeftemplateData(theEnv)->DeftemplateModuleIndex);
for (theDeftemplate = (struct deftemplate *) theItem->firstItem;
theDeftemplate != NULL ;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,theDeftemplate))
{
/*=======================================*/
/* If the deftemplate can be seen by the */
/* current module, then it is in scope. */
/*=======================================*/
if (FindImportedConstruct(theEnv,"deftemplate",theModule,
ValueToString(theDeftemplate->header.name),
&moduleCount,true,NULL) != NULL)
{ theDeftemplate->inScope = true; }
else
{ theDeftemplate->inScope = false; }
}
}
}
/***************************************************
NAME : ReplaceTemplateNameWithReference
DESCRIPTION : In parsing an fact-set query,
this function replaces a constant
template name with an actual pointer
to the template
INPUTS : The expression
RETURNS : TRUE if all OK, FALSE
if template cannot be found
SIDE EFFECTS : The expression type and value are
modified if template is found
NOTES : Searches current and imported
modules for reference
***************************************************/
static intBool ReplaceTemplateNameWithReference(
void *theEnv,
EXPRESSION *theExp)
{
const char *theTemplateName;
void *theDeftemplate;
int count;
if (theExp->type == SYMBOL)
{
theTemplateName = ValueToString(theExp->value);
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,theTemplateName,
&count,TRUE,NULL);
if (theDeftemplate == NULL)
{
CantFindItemErrorMessage(theEnv,"deftemplate",theTemplateName);
return(FALSE);
}
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"deftemplate",theTemplateName);
return(FALSE);
}
theExp->type = DEFTEMPLATE_PTR;
theExp->value = theDeftemplate;
#if (! RUN_TIME) && (! BLOAD_ONLY)
if (! ConstructData(theEnv)->ParsingConstruct)
{ ConstructData(theEnv)->DanglingConstructs++; }
#endif
}
return(TRUE);
}
static int ParseImportSpec(
void *theEnv,
char *readSource,
struct token *theToken,
struct defmodule *newModule)
{
struct defmodule *theModule;
struct portItem *thePort, *oldImportSpec;
int found, count;
/*===========================*/
/* Look for the module name. */
/*===========================*/
SavePPBuffer(theEnv," ");
GetToken(theEnv,readSource,theToken);
if (theToken->type != SYMBOL)
{
SyntaxErrorMessage(theEnv,"defmodule import specification");
return(TRUE);
}
/*=====================================*/
/* Verify the existence of the module. */
/*=====================================*/
if ((theModule = (struct defmodule *)
EnvFindDefmodule(theEnv,ValueToString(theToken->value))) == NULL)
{
CantFindItemErrorMessage(theEnv,"defmodule",ValueToString(theToken->value));
return(TRUE);
}
/*========================================*/
/* If the specified module doesn't export */
/* any constructs, then the import */
/* specification is meaningless. */
/*========================================*/
if (theModule->exportList == NULL)
{
NotExportedErrorMessage(theEnv,EnvGetDefmoduleName(theEnv,theModule),NULL,NULL);
return(TRUE);
}
/*==============================================*/
/* Parse the remaining portion of the import */
/* specification and return if an error occurs. */
/*==============================================*/
oldImportSpec = newModule->importList;
if (ParseExportSpec(theEnv,readSource,theToken,newModule,theModule)) return(TRUE);
/*========================================================*/
/* If the ?NONE keyword was used with the import spec, */
/* then no constructs were actually imported and the */
/* import spec does not need to be checked for conflicts. */
/*========================================================*/
if (newModule->importList == oldImportSpec) return(FALSE);
/*======================================================*/
/* Check to see if the construct being imported can be */
/* by the specified module. This check exported doesn't */
/* guarantee that a specific named construct actually */
/* exists. It just checks that it could be exported if */
/* it does exists. */
/*======================================================*/
if (newModule->importList->constructType != NULL)
{
/*=============================*/
/* Look for the construct in */
/* the module that exports it. */
/*=============================*/
found = FALSE;
for (thePort = theModule->exportList;
(thePort != NULL) && (! found);
thePort = thePort->next)
{
if (thePort->constructType == NULL) found = TRUE;
else if (thePort->constructType == newModule->importList->constructType)
{
if (newModule->importList->constructName == NULL) found = TRUE;
else if (thePort->constructName == NULL) found = TRUE;
else if (thePort->constructName == newModule->importList->constructName)
{ found = TRUE; }
}
}
/*=======================================*/
/* If it's not exported by the specified */
/* module, print an error message. */
/*=======================================*/
if (! found)
{
if (newModule->importList->constructName == NULL)
{
NotExportedErrorMessage(theEnv,EnvGetDefmoduleName(theEnv,theModule),
ValueToString(newModule->importList->constructType),
NULL);
}
else
{
NotExportedErrorMessage(theEnv,EnvGetDefmoduleName(theEnv,theModule),
ValueToString(newModule->importList->constructType),
ValueToString(newModule->importList->constructName));
}
return(TRUE);
}
}
/*======================================================*/
/* Verify that specific named constructs actually exist */
/* and can be seen from the module importing them. */
/*======================================================*/
SaveCurrentModule(theEnv);
EnvSetCurrentModule(theEnv,(void *) newModule);
for (thePort = newModule->importList;
thePort != NULL;
thePort = thePort->next)
{
if ((thePort->constructType == NULL) || (thePort->constructName == NULL))
{ continue; }
theModule = (struct defmodule *)
EnvFindDefmodule(theEnv,ValueToString(thePort->moduleName));
EnvSetCurrentModule(theEnv,theModule);
if (FindImportedConstruct(theEnv,ValueToString(thePort->constructType),NULL,
ValueToString(thePort->constructName),&count,
TRUE,FALSE) == NULL)
{
NotExportedErrorMessage(theEnv,EnvGetDefmoduleName(theEnv,theModule),
ValueToString(thePort->constructType),
ValueToString(thePort->constructName));
RestoreCurrentModule(theEnv);
return(TRUE);
}
}
RestoreCurrentModule(theEnv);
/*===============================================*/
/* The import list has been successfully parsed. */
/*===============================================*/
return(FALSE);
}
globle int FindImportExportConflict(
void *theEnv,
char *constructName,
struct defmodule *matchModule,
char *findName)
{
struct defmodule *theModule;
struct moduleItem *theModuleItem;
int count;
/*===========================================================*/
/* If the construct type can't be imported or exported, then */
/* it's not possible to have an import/export conflict. */
/*===========================================================*/
if (ValidPortConstructItem(theEnv,constructName) == NULL) return(FALSE);
/*============================================*/
/* There module name should already have been */
/* separated fromthe construct's name. */
/*============================================*/
if (FindModuleSeparator(findName)) return(FALSE);
/*===============================================================*/
/* The construct must be capable of being stored within a module */
/* (this test should never fail). The construct must also have */
/* a find function associated with it so we can actually look */
/* for import/export conflicts. */
/*===============================================================*/
if ((theModuleItem = FindModuleItem(theEnv,constructName)) == NULL) return(FALSE);
if (theModuleItem->findFunction == NULL) return(FALSE);
/*==========================*/
/* Save the current module. */
/*==========================*/
SaveCurrentModule(theEnv);
/*================================================================*/
/* Look at each module and count each definition of the specified */
/* construct which is visible to the module. If more than one */
/* definition is visible, then an import/export conflict exists */
/* and TRUE is returned. */
/*================================================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
FindImportedConstruct(theEnv,constructName,NULL,findName,&count,TRUE,matchModule);
if (count > 1)
{
RestoreCurrentModule(theEnv);
return(TRUE);
}
}
/*==========================================*/
/* Restore the current module. No conflicts */
/* were detected so FALSE is returned. */
/*==========================================*/
RestoreCurrentModule(theEnv);
return(FALSE);
}
globle struct expr *GetRHSPattern(
char *readSource,
struct token *tempToken,
int *error,
int constantsOnly,
int readFirstParen,
int checkFirstParen,
int endType)
{
struct expr *lastOne = NULL;
struct expr *nextOne, *firstOne, *argHead = NULL;
int printError, count;
struct deftemplate *theDeftemplate;
struct symbolHashNode *templateName;
/*=================================================*/
/* Get the opening parenthesis of the RHS pattern. */
/*=================================================*/
*error = FALSE;
if (readFirstParen) GetToken(readSource,tempToken);
if (checkFirstParen)
{
if (tempToken->type == endType) return(NULL);
if (tempToken->type != LPAREN)
{
SyntaxErrorMessage("RHS patterns");
*error = TRUE;
return(NULL);
}
}
/*======================================================*/
/* The first field of an asserted fact must be a symbol */
/* (but not = or : which have special significance). */
/*======================================================*/
GetToken(readSource,tempToken);
if (tempToken->type != SYMBOL)
{
SyntaxErrorMessage("first field of a RHS pattern");
*error = TRUE;
return(NULL);
}
else if ((strcmp(ValueToString(tempToken->value),"=") == 0) ||
(strcmp(ValueToString(tempToken->value),":") == 0))
{
SyntaxErrorMessage("first field of a RHS pattern");
*error = TRUE;
return(NULL);
}
/*=========================================================*/
/* Check to see if the relation name is a reserved symbol. */
/*=========================================================*/
templateName = (struct symbolHashNode *) tempToken->value;
if (ReservedPatternSymbol(ValueToString(templateName),NULL))
{
ReservedPatternSymbolErrorMsg(ValueToString(templateName),"a relation name");
*error = TRUE;
return(NULL);
}
/*============================================================*/
/* A module separator in the name is illegal in this context. */
/*============================================================*/
if (FindModuleSeparator(ValueToString(templateName)))
{
IllegalModuleSpecifierMessage();
*error = TRUE;
return(NULL);
}
/*=============================================================*/
/* Determine if there is an associated deftemplate. If so, let */
/* the deftemplate parsing functions parse the RHS pattern and */
/* then return the fact pattern that was parsed. */
/*=============================================================*/
theDeftemplate = (struct deftemplate *)
FindImportedConstruct("deftemplate",NULL,ValueToString(templateName),
&count,TRUE,NULL);
if (count > 1)
{
AmbiguousReferenceErrorMessage("deftemplate",ValueToString(templateName));
*error = TRUE;
return(NULL);
}
/*======================================================*/
/* If no deftemplate exists with the specified relation */
/* name, then create an implied deftemplate. */
/*======================================================*/
if (theDeftemplate == NULL)
#if (! BLOAD_ONLY) && (! RUN_TIME)
{
#if BLOAD || BLOAD_AND_BSAVE
if ((Bloaded()) && (! CheckSyntaxMode))
{
NoSuchTemplateError(ValueToString(templateName));
*error = TRUE;
return(NULL);
}
#endif
#if DEFMODULE_CONSTRUCT
if (FindImportExportConflict("deftemplate",((struct defmodule *) GetCurrentModule()),ValueToString(templateName)))
{
ImportExportConflictMessage("implied deftemplate",ValueToString(templateName),NULL,NULL);
*error = TRUE;
return(NULL);
}
#endif
if (! CheckSyntaxMode)
{ theDeftemplate = CreateImpliedDeftemplate((SYMBOL_HN *) templateName,TRUE); }
}
#else
{
NoSuchTemplateError(ValueToString(templateName));
*error = TRUE;
return(NULL);
}
#endif
/*=========================================*/
/* If an explicit deftemplate exists, then */
/* parse the fact as a deftemplate fact. */
/*=========================================*/
if ((theDeftemplate != NULL) && (theDeftemplate->implied == FALSE))
{
firstOne = GenConstant(DEFTEMPLATE_PTR,theDeftemplate);
firstOne->nextArg = ParseAssertTemplate(readSource,tempToken,
error,endType,
constantsOnly,theDeftemplate);
if (*error)
{
ReturnExpression(firstOne);
firstOne = NULL;
}
return(firstOne);
}
/*========================================*/
/* Parse the fact as an ordered RHS fact. */
/*========================================*/
firstOne = GenConstant(DEFTEMPLATE_PTR,theDeftemplate);
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
while ((nextOne = GetAssertArgument(readSource,tempToken,
error,endType,constantsOnly,&printError)) != NULL)
{
if (argHead == NULL) argHead = nextOne;
else lastOne->nextArg = nextOne;
lastOne = nextOne;
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
}
/*===========================================================*/
/* If an error occurred, set the error flag and return NULL. */
/*===========================================================*/
if (*error)
{
if (printError) SyntaxErrorMessage("RHS patterns");
ReturnExpression(firstOne);
ReturnExpression(argHead);
return(NULL);
}
/*=====================================*/
/* Fix the pretty print representation */
/* of the RHS ordered fact. */
/*=====================================*/
#if (! RUN_TIME) && (! BLOAD_ONLY)
PPBackup();
PPBackup();
SavePPBuffer(tempToken->printForm);
#endif
/*==========================================================*/
/* Ordered fact assertions are processed by stuffing all of */
/* the fact's proposition (except the relation name) into a */
/* single multifield slot. */
/*==========================================================*/
firstOne->nextArg = GenConstant(FACT_STORE_MULTIFIELD,AddBitMap("\0",1));
firstOne->nextArg->argList = argHead;
/*==============================*/
/* Return the RHS ordered fact. */
/*==============================*/
return(firstOne);
}
globle struct lhsParseNode *FactPatternParse(
void *theEnv,
char *readSource,
struct token *theToken)
{
struct deftemplate *theDeftemplate;
int count;
/*=========================================*/
/* A module separator can not be included */
/* as part of the pattern's relation name. */
/*=========================================*/
if (FindModuleSeparator(ValueToString(theToken->value)))
{
IllegalModuleSpecifierMessage(theEnv);
return(NULL);
}
/*=========================================================*/
/* Find the deftemplate associated with the relation name. */
/*=========================================================*/
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,ValueToString(theToken->value),
&count,TRUE,NULL);
if (count > 1)
{
AmbiguousReferenceErrorMessage(theEnv,"deftemplate",ValueToString(theToken->value));
return(NULL);
}
/*======================================================*/
/* If no deftemplate exists with the specified relation */
/* name, then create an implied deftemplate. */
/*======================================================*/
if (theDeftemplate == NULL)
{
#if DEFMODULE_CONSTRUCT
if (FindImportExportConflict(theEnv,"deftemplate",((struct defmodule *) EnvGetCurrentModule(theEnv)),ValueToString(theToken->value)))
{
ImportExportConflictMessage(theEnv,"implied deftemplate",ValueToString(theToken->value),NULL,NULL);
return(NULL);
}
#endif /* DEFMODULE_CONSTRUCT */
if (! ConstructData(theEnv)->CheckSyntaxMode)
{ theDeftemplate = CreateImpliedDeftemplate(theEnv,(SYMBOL_HN *) theToken->value,TRUE); }
else
{ theDeftemplate = NULL; }
}
/*===============================================*/
/* If an explicit deftemplate exists, then parse */
/* the pattern as a deftemplate pattern. */
/*===============================================*/
if ((theDeftemplate != NULL) && (theDeftemplate->implied == FALSE))
{ return(DeftemplateLHSParse(theEnv,readSource,theDeftemplate)); }
/*================================*/
/* Parse an ordered fact pattern. */
/*================================*/
return(SequenceRestrictionParse(theEnv,readSource,theToken));
}
static struct expr *BindParse(
void *theEnv,
struct expr *top,
char *infile)
{
struct token theToken;
SYMBOL_HN *variableName;
struct expr *texp;
CONSTRAINT_RECORD *theConstraint = NULL;
#if DEFGLOBAL_CONSTRUCT
struct defglobal *theGlobal;
int count;
#endif
SavePPBuffer(theEnv," ");
/*=============================================*/
/* Next token must be the name of the variable */
/* to be bound. */
/*=============================================*/
GetToken(theEnv,infile,&theToken);
if ((theToken.type != SF_VARIABLE) && (theToken.type != GBL_VARIABLE))
{
if ((theToken.type != MF_VARIABLE) || ExpressionData(theEnv)->SequenceOpMode)
{
SyntaxErrorMessage(theEnv,"bind function");
ReturnExpression(theEnv,top);
return(NULL);
}
}
/*==============================*/
/* Process the bind expression. */
/*==============================*/
top->argList = GenConstant(theEnv,SYMBOL,theToken.value);
variableName = (SYMBOL_HN *) theToken.value;
#if DEFGLOBAL_CONSTRUCT
if ((theToken.type == GBL_VARIABLE) ?
((theGlobal = (struct defglobal *)
FindImportedConstruct(theEnv,"defglobal",NULL,ValueToString(variableName),
&count,TRUE,FALSE)) != NULL) :
FALSE)
{
top->argList->type = DEFGLOBAL_PTR;
top->argList->value = (void *) theGlobal;
}
else if (theToken.type == GBL_VARIABLE)
{
GlobalReferenceErrorMessage(theEnv,ValueToString(variableName));
ReturnExpression(theEnv,top);
return(NULL);
}
#endif
texp = get_struct(theEnv,expr);
texp->argList = texp->nextArg = NULL;
if (CollectArguments(theEnv,texp,infile) == NULL)
{
ReturnExpression(theEnv,top);
return(NULL);
}
top->argList->nextArg = texp->argList;
rtn_struct(theEnv,expr,texp);
#if DEFGLOBAL_CONSTRUCT
if (top->argList->type == DEFGLOBAL_PTR) return(top);
#endif
if (top->argList->nextArg != NULL)
{ theConstraint = ExpressionToConstraintRecord(theEnv,top->argList->nextArg); }
AddBindName(theEnv,variableName,theConstraint);
return(top);
}
static struct patternNodeHeader *PlaceFactPattern(
void *theEnv,
struct lhsParseNode *thePattern)
{
struct lhsParseNode *tempPattern = NULL;
struct factPatternNode *currentLevel, *lastLevel;
struct factPatternNode *nodeBeforeMatch, *newNode = NULL;
unsigned endSlot;
int count;
char *deftemplateName;
/*======================================================================*/
/* Get the name of the deftemplate associated with the pattern being */
/* added (recall that the first field of any pattern must be a symbol). */
/*======================================================================*/
deftemplateName = ValueToString(thePattern->right->bottom->value);
/*=====================================================*/
/* Remove any slot tests that test only for existance. */
/*=====================================================*/
thePattern->right = RemoveUnneededSlots(theEnv,thePattern->right);
/*========================================================*/
/* If the constant test for the relation name is the only */
/* pattern network test and there are no other network */
/* tests, then remove the test, but keep the node since */
/* there must be a link from the fact pattern network to */
/* the join network. Otherwise, remove the test for the */
/* relation name since this test has already been done */
/* before entering the pattern network (since each */
/* deftemplate has its own pattern network). */
/*========================================================*/
if (thePattern->right->right == NULL)
{
ReturnExpression(theEnv,thePattern->right->networkTest);
thePattern->right->networkTest = NULL;
}
else
{
tempPattern = thePattern->right;
thePattern->right = thePattern->right->right;
tempPattern->right = NULL;
ReturnLHSParseNodes(theEnv,tempPattern);
tempPattern = NULL;
}
/*============================================================*/
/* Get a pointer to the deftemplate data structure associated */
/* with the pattern (use the deftemplate name extracted from */
/* the first field of the pattern). */
/*============================================================*/
FactData(theEnv)->CurrentDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,
deftemplateName,&count,
TRUE,NULL);
/*================================================*/
/* Initialize some pointers to indicate where the */
/* pattern is being added to the pattern network. */
/*================================================*/
currentLevel = FactData(theEnv)->CurrentDeftemplate->patternNetwork;
lastLevel = NULL;
thePattern = thePattern->right;
/*===========================================*/
/* Loop until all fields in the pattern have */
/* been added to the pattern network. */
/*===========================================*/
while (thePattern != NULL)
{
/*===========================================================*/
/* If a multifield slot is being processed, then process the */
/* pattern nodes attached to the multifield pattern node. */
/*===========================================================*/
if (thePattern->multifieldSlot)
{
tempPattern = thePattern;
thePattern = thePattern->bottom;
}
/*============================================*/
/* Determine if the last pattern field within */
/* a multifield slot is being processed. */
/*============================================*/
if ((thePattern->right == NULL) && (tempPattern != NULL))
{ endSlot = TRUE; }
else
{ endSlot = FALSE; }
/*========================================*/
/* Is there a node in the pattern network */
/* that can be reused (shared)? */
/*========================================*/
newNode = FindPatternNode(currentLevel,thePattern,&nodeBeforeMatch,endSlot);
/*================================================*/
/* If the pattern node cannot be shared, then add */
/* a new pattern node to the pattern network. */
/*================================================*/
if (newNode == NULL)
{ newNode = CreateNewPatternNode(theEnv,thePattern,nodeBeforeMatch,lastLevel,endSlot); }
/*===========================================================*/
/* Move on to the next field in the new pattern to be added. */
/*===========================================================*/
if ((thePattern->right == NULL) && (tempPattern != NULL))
{
thePattern = tempPattern;
tempPattern = NULL;
}
thePattern = thePattern->right;
/*==========================================================*/
/* If there are no more pattern nodes to be added to the */
/* pattern network, then mark the last pattern node added */
/* as a stop node (i.e. if you get to this node and the */
/* network test succeeds, then a pattern has been matched). */
/*==========================================================*/
if (thePattern == NULL) newNode->header.stopNode = TRUE;
/*================================================*/
/* Update the pointers which indicate where we're */
/* trying to add the new pattern to the currently */
/* existing pattern network. */
/*================================================*/
lastLevel = newNode;
currentLevel = newNode->nextLevel;
}
/*==================================================*/
/* Return the leaf node of the newly added pattern. */
/*==================================================*/
return((struct patternNodeHeader *) newNode);
}
globle struct expr *GetRHSPattern(
char *readSource,
struct token *tempToken,
int *error,
int constantsOnly,
int readFirstParen,
int checkFirstParen,
int endType)
{
struct expr *lastOne = NULL;
struct expr *nextOne, *firstOne, *argHead = NULL;
int printError, count;
struct deftemplate *theDeftemplate;
struct symbolHashNode *templateName;
/*=================================================*/
/* Get the opening parenthesis of the RHS pattern. */
/*=================================================*/
*error = FALSE;
if (readFirstParen) GetToken(readSource,tempToken);
if (checkFirstParen)
{
if (tempToken->type == endType) return(NULL);
if (tempToken->type != LPAREN)
{
SyntaxErrorMessage("RHS patterns");
*error = TRUE;
return(NULL);
}
}
/*======================================================*/
/* The first field of an asserted fact must be a symbol */
/* (but not = or : which have special significance). */
/*======================================================*/
GetToken(readSource,tempToken);
if (tempToken->type != SYMBOL)
{
SyntaxErrorMessage("first field of a RHS pattern");
*error = TRUE;
return(NULL);
}
else if ((strcmp(ValueToString(tempToken->value),"=") == 0) ||
(strcmp(ValueToString(tempToken->value),":") == 0))
{
SyntaxErrorMessage("first field of a RHS pattern");
*error = TRUE;
return(NULL);
}
/*=========================================================*/
/* Check to see if the relation name is a reserved symbol. */
/*=========================================================*/
templateName = (struct symbolHashNode *) tempToken->value;
if (ReservedPatternSymbol(ValueToString(templateName),NULL))
{
ReservedPatternSymbolErrorMsg(ValueToString(templateName),"a relation name");
*error = TRUE;
return(NULL);
}
/*============================================================*/
/* A module separator in the name is illegal in this context. */
/*============================================================*/
if (FindModuleSeparator(ValueToString(templateName)))
{
IllegalModuleSpecifierMessage();
*error = TRUE;
return(NULL);
}
/*=============================================================*/
/* Determine if there is an associated deftemplate. If so, let */
/* the deftemplate parsing functions parse the RHS pattern and */
/* then return the fact pattern that was parsed. */
/*=============================================================*/
theDeftemplate = (struct deftemplate *)
FindImportedConstruct("deftemplate",NULL,ValueToString(templateName),
&count,TRUE,NULL);
if (count > 1)
{
AmbiguousReferenceErrorMessage("deftemplate",ValueToString(templateName));
*error = TRUE;
return(NULL);
}
/*======================================================*/
/* If no deftemplate exists with the specified relation */
/* name, then create an implied deftemplate. */
/*======================================================*/
if (theDeftemplate == NULL)
#if (! BLOAD_ONLY) && (! RUN_TIME)
{
#if BLOAD || BLOAD_AND_BSAVE
if ((Bloaded()) && (! CheckSyntaxMode))
{
NoSuchTemplateError(ValueToString(templateName));
*error = TRUE;
return(NULL);
}
#endif
#if DEFMODULE_CONSTRUCT
if (FindImportExportConflict("deftemplate",((struct defmodule *) GetCurrentModule()),ValueToString(templateName)))
{
ImportExportConflictMessage("implied deftemplate",ValueToString(templateName),NULL,NULL);
*error = TRUE;
return(NULL);
}
#endif
if (! CheckSyntaxMode)
{ theDeftemplate = CreateImpliedDeftemplate((SYMBOL_HN *) templateName,TRUE); }
}
#else
{
NoSuchTemplateError(ValueToString(templateName));
*error = TRUE;
return(NULL);
}
#endif
/*=========================================*/
/* If an explicit deftemplate exists, then */
/* parse the fact as a deftemplate fact. */
/*=========================================*/
if ((theDeftemplate != NULL) && (theDeftemplate->implied == FALSE))
{
firstOne = GenConstant(DEFTEMPLATE_PTR,theDeftemplate);
#if FUZZY_DEFTEMPLATES
if (theDeftemplate->fuzzyTemplate != NULL)
firstOne->nextArg = ParseAssertFuzzyFact(readSource,tempToken,
error,endType,
constantsOnly,theDeftemplate,
TRUE);
else
#endif
firstOne->nextArg = ParseAssertTemplate(readSource,tempToken,
error,endType,
constantsOnly,theDeftemplate);
if (*error)
{
ReturnExpression(firstOne);
firstOne = NULL;
}
#if CERTAINTY_FACTORS
else
{
/* if certaintly factors allowed then the next item after a fact
specifier COULD be a certainty factor spec --- CF x.xxx
*/
SavePPBuffer(" ");
GetToken(readSource,tempToken);
if ((tempToken->type == SYMBOL) &&
((strcmp(ValueToString(tempToken->value),"CF") == 0) ||
(strcmp(ValueToString(tempToken->value),"cf") == 0))
)
{
struct expr *CFexpr;
/* expecting a certainty factor (float) expression */
/* tokenToFloatExpression expect 1st token already read */
SavePPBuffer(" ");
GetToken(readSource,tempToken);
CFexpr = tokenToFloatExpression(readSource,tempToken,error,constantsOnly);
if (*error)
{
ReturnExpression(firstOne);
return( NULL );
}
if (CFexpr->type == FLOAT) /* if constant -- check range */
{
double cfval = ValueToDouble(CFexpr->value);
if (cfval > 1.0 || cfval < 0.0)
{
*error = TRUE;
ReturnExpression(CFexpr);
cfRangeError();
ReturnExpression(firstOne);
return( NULL );
}
}
/* store the CF expression in the argList of the DEFTEMPLATE_PTR expr */
firstOne->argList = CFexpr;
}
else
{
/* Do an 'UnGetToken' function here to undo the lookahead for a CF.
Also need to PPBackup over the space added before reading the
potential CF expression -- UnGetToken does one PPBackup over the
token which was added to the PP Buffer
*/
UnGetToken(tempToken);
PPBackup();
}
}
#endif
return(firstOne);
}
/*========================================*/
/* Parse the fact as an ordered RHS fact. */
/*========================================*/
firstOne = GenConstant(DEFTEMPLATE_PTR,theDeftemplate);
#if FUZZY_DEFTEMPLATES
/*=============================================*/
/* Fuzzy facts parsed differently */
/*=============================================*/
if (theDeftemplate->fuzzyTemplate != NULL)
{
firstOne->nextArg = ParseAssertFuzzyFact(readSource,tempToken,
error,endType,
constantsOnly,theDeftemplate,
TRUE);
if (*error)
{
ReturnExpression(firstOne);
return(NULL);
}
}
else
{ /* --- matches } below with FUZZY_DEFTEMPLATES */
#endif /* FUZZY_DEFTEMPLATES */
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
while ((nextOne = GetAssertArgument(readSource,tempToken,
error,endType,constantsOnly,&printError)) != NULL)
{
if (argHead == NULL) argHead = nextOne;
else lastOne->nextArg = nextOne;
lastOne = nextOne;
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
}
/*===========================================================*/
/* If an error occurred, set the error flag and return NULL. */
/*===========================================================*/
if (*error)
{
if (printError) SyntaxErrorMessage("RHS patterns");
ReturnExpression(firstOne);
ReturnExpression(argHead);
return(NULL);
}
/*=====================================*/
/* Fix the pretty print representation */
/* of the RHS ordered fact. */
/*=====================================*/
#if (! RUN_TIME) && (! BLOAD_ONLY)
PPBackup();
PPBackup();
SavePPBuffer(tempToken->printForm);
#endif
/*==========================================================*/
/* Ordered fact assertions are processed by stuffing all of */
/* the fact's proposition (except the relation name) into a */
/* single multifield slot. */
/*==========================================================*/
firstOne->nextArg = GenConstant(FACT_STORE_MULTIFIELD,AddBitMap("\0",1));
firstOne->nextArg->argList = argHead;
#if FUZZY_DEFTEMPLATES
} /* --- matches else { above with FUZZY_DEFTEMPLATES */
#endif
#if CERTAINTY_FACTORS
/* if certaintly factors allowed then the next item after a fact
specifier could be a certainty factor spec --- CF x.xxx
*/
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
GetToken(readSource,tempToken);
if ((tempToken->type == SYMBOL) &&
((strcmp(ValueToString(tempToken->value),"CF") == 0) ||
(strcmp(ValueToString(tempToken->value),"cf") == 0))
)
{
struct expr *CFexpr;
/* expecting a certainty factor (float) expression */
/* tokenToFloatExpression expect 1st token already read */
#if (! RUN_TIME) && (! BLOAD_ONLY)
SavePPBuffer(" ");
#endif
GetToken(readSource,tempToken);
CFexpr = tokenToFloatExpression(readSource,tempToken,error,constantsOnly);
if (*error)
{
ReturnExpression(firstOne);
return( NULL );
}
if (CFexpr->type == FLOAT) /* if constant -- check range */
{
double cfval = ValueToDouble(CFexpr->value);
if (cfval > 1.0 || cfval < 0.0)
{
*error = TRUE;
ReturnExpression(CFexpr);
cfRangeError();
ReturnExpression(firstOne);
return( NULL );
}
}
/* store the CF expression in the argList of the DEFTEMPLATE_PTR expr */
firstOne->argList = CFexpr;
}
else
{
/* Do an 'UnGetToken' function here to undo the lookahead for a CF.
Also need to PPBackup over the space added before reading the
potential CF expression -- UnGetToken does one PPBackup over the
token which was added to the PP Buffer
*/
UnGetToken(tempToken);
#if (! RUN_TIME) && (! BLOAD_ONLY)
PPBackup();
#endif
}
#endif /* CERTAINTY_FACTORS */
/*==============================*/
/* Return the RHS ordered fact. */
/*==============================*/
return(firstOne);
}
static int FindMultiImportConflict(
void *theEnv,
struct defmodule *theModule)
{
struct defmodule *testModule;
int count;
struct portConstructItem *thePCItem;
struct construct *theConstruct;
void *theCItem;
/*==========================*/
/* Save the current module. */
/*==========================*/
SaveCurrentModule(theEnv);
/*============================*/
/* Loop through every module. */
/*============================*/
for (testModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
testModule != NULL;
testModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,testModule))
{
/*========================================*/
/* Loop through every construct type that */
/* can be imported/exported by a module. */
/*========================================*/
for (thePCItem = DefmoduleData(theEnv)->ListOfPortConstructItems;
thePCItem != NULL;
thePCItem = thePCItem->next)
{
EnvSetCurrentModule(theEnv,(void *) testModule);
/*=====================================================*/
/* Loop through every construct of the specified type. */
/*=====================================================*/
theConstruct = FindConstruct(theEnv,thePCItem->constructName);
for (theCItem = (*theConstruct->getNextItemFunction)(theEnv,NULL);
theCItem != NULL;
theCItem = (*theConstruct->getNextItemFunction)(theEnv,theCItem))
{
/*===============================================*/
/* Check to see if the specific construct in the */
/* module can be imported with more than one */
/* reference into the module we're examining for */
/* ambiguous import specifications. */
/*===============================================*/
EnvSetCurrentModule(theEnv,(void *) theModule);
FindImportedConstruct(theEnv,thePCItem->constructName,NULL,
ValueToString((*theConstruct->getConstructNameFunction)
((struct constructHeader *) theCItem)),
&count,FALSE,NULL);
if (count > 1)
{
ImportExportConflictMessage(theEnv,"defmodule",EnvGetDefmoduleName(theEnv,theModule),
thePCItem->constructName,
ValueToString((*theConstruct->getConstructNameFunction)
((struct constructHeader *) theCItem)));
RestoreCurrentModule(theEnv);
return(TRUE);
}
EnvSetCurrentModule(theEnv,(void *) testModule);
}
}
}
/*=============================*/
/* Restore the current module. */
/*=============================*/
RestoreCurrentModule(theEnv);
/*=======================================*/
/* Return FALSE to indicate no ambiguous */
/* references were found. */
/*=======================================*/
return(FALSE);
}
/*************************************************************
NAME : FormChain
DESCRIPTION : Builds a list of deftemplates to be used in
fact queries - uses parse form.
INPUTS : 1) Name of calling function for error msgs
2) Data object - must be a symbol or a
multifield value containing all symbols
The symbols must be names of existing templates
RETURNS : The query chain, or NULL on errors
SIDE EFFECTS : Memory allocated for chain
Busy count incremented for all templates
NOTES : None
*************************************************************/
static QUERY_TEMPLATE *FormChain(
Environment *theEnv,
const char *func,
Deftemplate *theDeftemplate,
UDFValue *val)
{
Deftemplate *templatePtr;
QUERY_TEMPLATE *head, *bot, *tmp;
size_t i; /* 6.04 Bug Fix */
const char *templateName;
unsigned int count;
if (theDeftemplate != NULL)
{
IncrementDeftemplateBusyCount(theEnv,theDeftemplate);
head = get_struct(theEnv,query_template);
head->templatePtr = theDeftemplate;
head->chain = NULL;
head->nxt = NULL;
return head;
}
if (val->header->type == SYMBOL_TYPE)
{
/*============================================*/
/* Allow instance-set query restrictions to */
/* have module specifier as part of the class */
/* name, but search imported defclasses too */
/* if a module specifier is not given. */
/*============================================*/
templatePtr = (Deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,val->lexemeValue->contents,
&count,true,NULL);
if (templatePtr == NULL)
{
CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",val->lexemeValue->contents,func,true);
return NULL;
}
IncrementDeftemplateBusyCount(theEnv,templatePtr);
head = get_struct(theEnv,query_template);
head->templatePtr = templatePtr;
head->chain = NULL;
head->nxt = NULL;
return head;
}
if (val->header->type == MULTIFIELD_TYPE)
{
head = bot = NULL;
for (i = val->begin ; i < (val->begin + val->range) ; i++)
{
if (val->multifieldValue->contents[i].header->type == SYMBOL_TYPE)
{
templateName = val->multifieldValue->contents[i].lexemeValue->contents;
templatePtr = (Deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,templateName,
&count,true,NULL);
if (templatePtr == NULL)
{
CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",templateName,func,true);
DeleteQueryTemplates(theEnv,head);
return NULL;
}
}
else
{
DeleteQueryTemplates(theEnv,head);
return NULL;
}
IncrementDeftemplateBusyCount(theEnv,templatePtr);
tmp = get_struct(theEnv,query_template);
tmp->templatePtr = templatePtr;
tmp->chain = NULL;
tmp->nxt = NULL;
if (head == NULL)
{ head = tmp; }
else
{ bot->chain = tmp; }
bot = tmp;
}
return head;
}
return NULL;
}
static DATA_OBJECT_PTR GetSaveFactsDeftemplateNames(
void *theEnv,
struct expr *theList,
int saveCode,
int *count,
int *error)
{
struct expr *tempList;
DATA_OBJECT_PTR theDOArray;
int i, tempCount;
struct deftemplate *theDeftemplate = NULL;
/*=============================*/
/* Initialize the error state. */
/*=============================*/
*error = FALSE;
/*=====================================================*/
/* If no deftemplate names were specified as arguments */
/* then the deftemplate name list is empty. */
/*=====================================================*/
if (theList == NULL)
{
*count = 0;
return(NULL);
}
/*======================================*/
/* Determine the number of deftemplate */
/* names to be stored in the name list. */
/*======================================*/
for (tempList = theList, *count = 0;
tempList != NULL;
tempList = tempList->nextArg, (*count)++)
{ /* Do Nothing */ }
/*=========================================*/
/* Allocate the storage for the name list. */
/*=========================================*/
theDOArray = (DATA_OBJECT_PTR) gm3(theEnv,(long) sizeof(DATA_OBJECT) * *count);
/*=====================================*/
/* Loop through each of the arguments. */
/*=====================================*/
for (tempList = theList, i = 0;
i < *count;
tempList = tempList->nextArg, i++)
{
/*========================*/
/* Evaluate the argument. */
/*========================*/
EvaluateExpression(theEnv,tempList,&theDOArray[i]);
if (EvaluationData(theEnv)->EvaluationError)
{
*error = TRUE;
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
/*======================================*/
/* A deftemplate name must be a symbol. */
/*======================================*/
if (theDOArray[i].type != SYMBOL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"symbol");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
/*===================================================*/
/* Find the deftemplate. For a local save, look only */
/* in the current module. For a visible save, look */
/* in all visible modules. */
/*===================================================*/
if (saveCode == LOCAL_SAVE)
{
theDeftemplate = (struct deftemplate *)
EnvFindDeftemplate(theEnv,ValueToString(theDOArray[i].value));
if (theDeftemplate == NULL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"local deftemplate name");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
}
else if (saveCode == VISIBLE_SAVE)
{
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,(char*)"deftemplate",NULL,
ValueToString(theDOArray[i].value),
&tempCount,TRUE,NULL);
if (theDeftemplate == NULL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"visible deftemplate name");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
}
/*==================================*/
/* Add a pointer to the deftemplate */
/* to the array being created. */
/*==================================*/
theDOArray[i].type = DEFTEMPLATE_PTR;
theDOArray[i].value = (void *) theDeftemplate;
}
/*===================================*/
/* Return the array of deftemplates. */
/*===================================*/
return(theDOArray);
}
/*************************************************************
NAME : FormChain
DESCRIPTION : Builds a list of classes to be used in
fact queries - uses parse form.
INPUTS : 1) Name of calling function for error msgs
2) Data object - must be a symbol or a
multifield value containing all symbols
The symbols must be names of existing templates
RETURNS : The query chain, or NULL on errors
SIDE EFFECTS : Memory allocated for chain
Busy count incremented for all templates
NOTES : None
*************************************************************/
static QUERY_TEMPLATE *FormChain(
void *theEnv,
char *func,
DATA_OBJECT *val)
{
struct deftemplate *templatePtr;
QUERY_TEMPLATE *head,*bot,*tmp;
register long i,end; /* 6.04 Bug Fix */
char *templateName;
int count;
if (val->type == DEFTEMPLATE_PTR)
{
IncrementDeftemplateBusyCount(theEnv,(void *) val->value);
head = get_struct(theEnv,query_template);
head->templatePtr = (struct deftemplate *) val->value;
head->chain = NULL;
head->nxt = NULL;
return(head);
}
if (val->type == SYMBOL)
{
/* ===============================================
Allow instance-set query restrictions to have a
module specifier as part of the class name,
but search imported defclasses too if a
module specifier is not given
=============================================== */
templatePtr = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,DOPToString(val),
&count,TRUE,NULL);
if (templatePtr == NULL)
{
CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",DOPToString(val),func);
return(NULL);
}
IncrementDeftemplateBusyCount(theEnv,(void *) templatePtr);
head = get_struct(theEnv,query_template);
head->templatePtr = templatePtr;
head->chain = NULL;
head->nxt = NULL;
return(head);
}
if (val->type == MULTIFIELD)
{
head = bot = NULL;
end = GetpDOEnd(val);
for (i = GetpDOBegin(val) ; i <= end ; i++)
{
if (GetMFType(val->value,i) == SYMBOL)
{
templateName = ValueToString(GetMFValue(val->value,i));
templatePtr = (struct deftemplate *)
FindImportedConstruct(theEnv,"deftemplate",NULL,templateName,
&count,TRUE,NULL);
if (templatePtr == NULL)
{
CantFindItemInFunctionErrorMessage(theEnv,"deftemplate",templateName,func);
DeleteQueryTemplates(theEnv,head);
return(NULL);
}
}
else
{
DeleteQueryTemplates(theEnv,head);
return(NULL);
}
IncrementDeftemplateBusyCount(theEnv,(void *) templatePtr);
tmp = get_struct(theEnv,query_template);
tmp->templatePtr = templatePtr;
tmp->chain = NULL;
tmp->nxt = NULL;
if (head == NULL)
head = tmp;
else
bot->chain = tmp;
bot = tmp;
}
return(head);
}
return(NULL);
}
static struct lhsParseNode *CheckExpression(
void *theEnv,
struct lhsParseNode *exprPtr,
struct lhsParseNode *lastOne,
int whichCE,
struct symbolHashNode *slotName,
int theField)
{
struct lhsParseNode *rv;
int i = 1;
while (exprPtr != NULL)
{
/*===============================================================*/
/* Check that single field variables contained in the expression */
/* were previously defined in the LHS. Also check to see if the */
/* variable has unmatchable constraints. */
/*===============================================================*/
if (exprPtr->type == SF_VARIABLE)
{
if (exprPtr->referringNode == NULL)
{
VariableReferenceErrorMessage(theEnv,(SYMBOL_HN *) exprPtr->value,lastOne,
whichCE,slotName,theField);
return(exprPtr);
}
else if ((UnmatchableConstraint(exprPtr->constraints)) &&
EnvGetStaticConstraintChecking(theEnv))
{
ConstraintReferenceErrorMessage(theEnv,(SYMBOL_HN *) exprPtr->value,lastOne,i,
whichCE,slotName,theField);
return(exprPtr);
}
}
/*==================================================*/
/* Check that multifield variables contained in the */
/* expression were previously defined in the LHS. */
/*==================================================*/
else if ((exprPtr->type == MF_VARIABLE) && (exprPtr->referringNode == NULL))
{
VariableReferenceErrorMessage(theEnv,(SYMBOL_HN *) exprPtr->value,lastOne,
whichCE,slotName,theField);
return(exprPtr);
}
/*=====================================================*/
/* Check that global variables are referenced properly */
/* (i.e. if you reference a global variable, it must */
/* already be defined by a defglobal construct). */
/*=====================================================*/
#if DEFGLOBAL_CONSTRUCT
else if (exprPtr->type == GBL_VARIABLE)
{
int count;
if (FindImportedConstruct(theEnv,"defglobal",NULL,ValueToString(exprPtr->value),
&count,TRUE,NULL) == NULL)
{
VariableReferenceErrorMessage(theEnv,(SYMBOL_HN *) exprPtr->value,lastOne,
whichCE,slotName,theField);
return(exprPtr);
}
}
#endif
/*============================================*/
/* Recursively check other function calls to */
/* insure variables are referenced correctly. */
/*============================================*/
else if (((exprPtr->type == FCALL)
#if DEFGENERIC_CONSTRUCT
|| (exprPtr->type == GCALL)
#endif
#if DEFFUNCTION_CONSTRUCT
|| (exprPtr->type == PCALL)
#endif
) && (exprPtr->bottom != NULL))
{
if ((rv = CheckExpression(theEnv,exprPtr->bottom,exprPtr,whichCE,slotName,theField)) != NULL)
{ return(rv); }
}
/*=============================================*/
/* Move on to the next part of the expression. */
/*=============================================*/
i++;
exprPtr = exprPtr->right;
}
/*================================================*/
/* Return NULL to indicate no error was detected. */
/*================================================*/
return(NULL);
}
