/***********************************************************************
NAME : IsMethodApplicable
DESCRIPTION : Tests to see if a method satsifies the arguments of a
generic function
A method is applicable if all its restrictions are
satisfied by the corresponding arguments
INPUTS : The method address
RETURNS : true if method is applicable, false otherwise
SIDE EFFECTS : Any query functions are evaluated
NOTES : Uses globals ProcParamArraySize and ProcParamArray
***********************************************************************/
bool IsMethodApplicable(
void *theEnv,
DEFMETHOD *meth)
{
DATA_OBJECT temp;
short i,j,k;
register RESTRICTION *rp;
#if OBJECT_SYSTEM
void *type;
#else
int type;
#endif
if ((ProceduralPrimitiveData(theEnv)->ProcParamArraySize < meth->minRestrictions) ||
((ProceduralPrimitiveData(theEnv)->ProcParamArraySize > meth->minRestrictions) && (meth->maxRestrictions != -1)))
return(false);
for (i = 0 , k = 0 ; i < ProceduralPrimitiveData(theEnv)->ProcParamArraySize ; i++)
{
rp = &meth->restrictions[k];
if (rp->tcnt != 0)
{
#if OBJECT_SYSTEM
type = (void *) DetermineRestrictionClass(theEnv,&ProceduralPrimitiveData(theEnv)->ProcParamArray[i]);
if (type == NULL)
return(false);
for (j = 0 ; j < rp->tcnt ; j++)
{
if (type == rp->types[j])
break;
if (HasSuperclass((DEFCLASS *) type,(DEFCLASS *) rp->types[j]))
break;
if (rp->types[j] == (void *) DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_ADDRESS])
{
if (ProceduralPrimitiveData(theEnv)->ProcParamArray[i].type == INSTANCE_ADDRESS)
break;
}
else if (rp->types[j] == (void *) DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME])
{
if (ProceduralPrimitiveData(theEnv)->ProcParamArray[i].type == INSTANCE_NAME)
break;
}
else if (rp->types[j] ==
(void *) DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME]->directSuperclasses.classArray[0])
{
if ((ProceduralPrimitiveData(theEnv)->ProcParamArray[i].type == INSTANCE_NAME) ||
(ProceduralPrimitiveData(theEnv)->ProcParamArray[i].type == INSTANCE_ADDRESS))
break;
}
}
#else
type = ProceduralPrimitiveData(theEnv)->ProcParamArray[i].type;
for (j = 0 ; j < rp->tcnt ; j++)
{
if (type == ValueToInteger(rp->types[j]))
break;
if (SubsumeType(type,ValueToInteger(rp->types[j])))
break;
}
#endif
if (j == rp->tcnt)
return(false);
}
if (rp->query != NULL)
{
DefgenericData(theEnv)->GenericCurrentArgument = &ProceduralPrimitiveData(theEnv)->ProcParamArray[i];
EvaluateExpression(theEnv,rp->query,&temp);
if ((temp.type != SYMBOL) ? false :
(temp.value == EnvFalseSymbol(theEnv)))
return(false);
}
if (((int) k) != meth->restrictionCount-1)
k++;
}
return(true);
}
/***********************************************************************
NAME : IsMethodApplicable
DESCRIPTION : Tests to see if a method satsifies the arguments of a
generic function
A method is applicable if all its restrictions are
satisfied by the corresponding arguments
INPUTS : The method address
RETURNS : True if method is applicable, false otherwise
SIDE EFFECTS : Any query functions are evaluated
NOTES : Uses globals ProcParamArraySize and ProcParamArray
***********************************************************************/
bool IsMethodApplicable(
Environment *theEnv,
Defmethod *meth)
{
UDFValue temp;
unsigned int i,j,k;
RESTRICTION *rp;
#if OBJECT_SYSTEM
Defclass *type;
#else
int type;
#endif
if (((ProceduralPrimitiveData(theEnv)->ProcParamArraySize < meth->minRestrictions) && (meth->minRestrictions != RESTRICTIONS_UNBOUNDED)) ||
((ProceduralPrimitiveData(theEnv)->ProcParamArraySize > meth->minRestrictions) && (meth->maxRestrictions != RESTRICTIONS_UNBOUNDED))) // TBD minRestrictions || maxRestrictions
return false;
for (i = 0 , k = 0 ; i < ProceduralPrimitiveData(theEnv)->ProcParamArraySize ; i++)
{
rp = &meth->restrictions[k];
if (rp->tcnt != 0)
{
#if OBJECT_SYSTEM
type = DetermineRestrictionClass(theEnv,&ProceduralPrimitiveData(theEnv)->ProcParamArray[i]);
if (type == NULL)
return false;
for (j = 0 ; j < rp->tcnt ; j++)
{
if (type == rp->types[j])
break;
if (HasSuperclass(type,(Defclass *) rp->types[j]))
break;
if (rp->types[j] == (void *) DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_ADDRESS_TYPE])
{
if (ProceduralPrimitiveData(theEnv)->ProcParamArray[i].header->type == INSTANCE_ADDRESS_TYPE)
break;
}
else if (rp->types[j] == (void *) DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME_TYPE])
{
if (ProceduralPrimitiveData(theEnv)->ProcParamArray[i].header->type == INSTANCE_NAME_TYPE)
break;
}
else if (rp->types[j] ==
DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME_TYPE]->directSuperclasses.classArray[0])
{
if ((ProceduralPrimitiveData(theEnv)->ProcParamArray[i].header->type == INSTANCE_NAME_TYPE) ||
(ProceduralPrimitiveData(theEnv)->ProcParamArray[i].header->type == INSTANCE_ADDRESS_TYPE))
break;
}
}
#else
type = ProceduralPrimitiveData(theEnv)->ProcParamArray[i].header->type;
for (j = 0 ; j < rp->tcnt ; j++)
{
if (type == ((CLIPSInteger *) (rp->types[j]))->contents)
break;
if (SubsumeType(type,((CLIPSInteger *) (rp->types[j]))->contents))
break;
}
#endif
if (j == rp->tcnt)
return false;
}
if (rp->query != NULL)
{
DefgenericData(theEnv)->GenericCurrentArgument = &ProceduralPrimitiveData(theEnv)->ProcParamArray[i];
EvaluateExpression(theEnv,rp->query,&temp);
if (temp.value == FalseSymbol(theEnv))
return false;
}
if ((k + 1) != meth->restrictionCount)
k++;
}
return true;
}