/*****************************************************
NAME : SlotInfoSupportFunction
DESCRIPTION : Support routine for slot-sources,
slot-facets, et. al.
INPUTS : 1) Data object buffer
2) Name of the H/L caller
3) Pointer to support function to call
RETURNS : Nothing useful
SIDE EFFECTS : Support function called and data
object buffer set
NOTES : None
*****************************************************/
static void SlotInfoSupportFunction(
DATA_OBJECT *result,
char *fnxname,
void (*fnx)(void *,char *,DATA_OBJECT *))
{
SYMBOL_HN *ssym;
DEFCLASS *cls;
ssym = CheckClassAndSlot(fnxname,&cls);
if (ssym == NULL)
{
SetMultifieldErrorValue(result);
return;
}
(*fnx)((void *) cls,ValueToString(ssym),result);
}
/***************************************************
NAME : CheckSlotExists
DESCRIPTION : Checks first two arguments of
a function for a valid class
and (inherited) slot
INPUTS : 1) The name of the function
2) A buffer to hold the found class
3) A flag indicating whether the
non-existence of the slot should
be an error
4) A flag indicating if the slot
can be inherited or not
RETURNS : NULL if slot not found, slot
descriptor otherwise
SIDE EFFECTS : Class buffer set if no errors,
NULL on errors
NOTES : None
***************************************************/
static SlotDescriptor *CheckSlotExists(
UDFContext *context,
const char *func,
Defclass **classBuffer,
bool existsErrorFlag,
bool inheritFlag)
{
CLIPSLexeme *ssym;
int slotIndex;
SlotDescriptor *sd;
Environment *theEnv = context->environment;
ssym = CheckClassAndSlot(context,func,classBuffer);
if (ssym == NULL)
return NULL;
slotIndex = FindInstanceTemplateSlot(theEnv,*classBuffer,ssym);
if (slotIndex == -1)
{
if (existsErrorFlag)
{
SlotExistError(theEnv,ssym->contents,func);
SetEvaluationError(theEnv,true);
}
return NULL;
}
sd = (*classBuffer)->instanceTemplate[slotIndex];
if ((sd->cls == *classBuffer) || inheritFlag)
{ return sd; }
PrintErrorID(theEnv,"CLASSEXM",1,false);
WriteString(theEnv,STDERR,"Inherited slot '");
WriteString(theEnv,STDERR,ssym->contents);
WriteString(theEnv,STDERR,"' from class ");
PrintClassName(theEnv,STDERR,sd->cls,true,false);
WriteString(theEnv,STDERR," is not valid for function '");
WriteString(theEnv,STDERR,func);
WriteString(theEnv,STDERR,"'.\n");
SetEvaluationError(theEnv,true);
return NULL;
}
/***************************************************
NAME : CheckSlotExists
DESCRIPTION : Checks first two arguments of
a function for a valid class
and (inherited) slot
INPUTS : 1) The name of the function
2) A buffer to hold the found class
3) A flag indicating whether the
non-existence of the slot should
be an error
4) A flag indicating if the slot
can be inherited or not
RETURNS : NULL if slot not found, slot
descriptor otherwise
SIDE EFFECTS : Class buffer set if no errors,
NULL on errors
NOTES : None
***************************************************/
static SLOT_DESC *CheckSlotExists(
void *theEnv,
char *func,
DEFCLASS **classBuffer,
intBool existsErrorFlag,
intBool inheritFlag)
{
SYMBOL_HN *ssym;
int slotIndex;
SLOT_DESC *sd;
ssym = CheckClassAndSlot(theEnv,func,classBuffer);
if (ssym == NULL)
return(NULL);
slotIndex = FindInstanceTemplateSlot(theEnv,*classBuffer,ssym);
if (slotIndex == -1)
{
if (existsErrorFlag)
{
SlotExistError(theEnv,ValueToString(ssym),func);
SetEvaluationError(theEnv,TRUE);
}
return(NULL);
}
sd = (*classBuffer)->instanceTemplate[slotIndex];
if ((sd->cls == *classBuffer) || inheritFlag)
return(sd);
PrintErrorID(theEnv,"CLASSEXM",1,FALSE);
EnvPrintRouter(theEnv,WERROR,"Inherited slot ");
EnvPrintRouter(theEnv,WERROR,ValueToString(ssym));
EnvPrintRouter(theEnv,WERROR," from class ");
PrintClassName(theEnv,WERROR,sd->cls,FALSE);
EnvPrintRouter(theEnv,WERROR," is not valid for function ");
EnvPrintRouter(theEnv,WERROR,func);
EnvPrintRouter(theEnv,WERROR,"\n");
SetEvaluationError(theEnv,TRUE);
return(NULL);
}
