/*******************************************************************
NAME : ParseRestrictionType
DESCRIPTION : Takes a string of type character codes (as given in
DefineFunction2()) and converts it into a method
restriction structure
INPUTS : The type character code
RETURNS : The restriction
SIDE EFFECTS : Restriction allocated
NOTES : None
*******************************************************************/
static RESTRICTION *ParseRestrictionType(
void *theEnv,
int code)
{
RESTRICTION *rptr;
CONSTRAINT_RECORD *rv;
EXPRESSION *types = NULL;
rptr = get_struct(theEnv,restriction);
rptr->query = NULL;
rv = ArgumentTypeToConstraintRecord(theEnv,code);
if (rv->anyAllowed == FALSE)
{
if (rv->symbolsAllowed && rv->stringsAllowed)
types = GenTypeExpression(theEnv,types,LEXEME_TYPE_CODE,-1,LEXEME_TYPE_NAME);
else if (rv->symbolsAllowed)
types = GenTypeExpression(theEnv,types,SYMBOL,SYMBOL,NULL);
else if (rv->stringsAllowed)
types = GenTypeExpression(theEnv,types,STRING,STRING,NULL);
if (rv->floatsAllowed && rv->integersAllowed)
types = GenTypeExpression(theEnv,types,NUMBER_TYPE_CODE,-1,NUMBER_TYPE_NAME);
else if (rv->integersAllowed)
types = GenTypeExpression(theEnv,types,INTEGER,INTEGER,NULL);
else if (rv->floatsAllowed)
types = GenTypeExpression(theEnv,types,FLOAT,FLOAT,NULL);
if (rv->instanceNamesAllowed && rv->instanceAddressesAllowed)
types = GenTypeExpression(theEnv,types,INSTANCE_TYPE_CODE,-1,INSTANCE_TYPE_NAME);
else if (rv->instanceNamesAllowed)
types = GenTypeExpression(theEnv,types,INSTANCE_NAME,INSTANCE_NAME,NULL);
else if (rv->instanceAddressesAllowed)
types = GenTypeExpression(theEnv,types,INSTANCE_ADDRESS,INSTANCE_ADDRESS,NULL);
if (rv->externalAddressesAllowed && rv->instanceAddressesAllowed &&
rv->factAddressesAllowed)
types = GenTypeExpression(theEnv,types,ADDRESS_TYPE_CODE,-1,ADDRESS_TYPE_NAME);
else
{
if (rv->externalAddressesAllowed)
types = GenTypeExpression(theEnv,types,EXTERNAL_ADDRESS,EXTERNAL_ADDRESS,NULL);
if (rv->instanceAddressesAllowed && (rv->instanceNamesAllowed == 0))
types = GenTypeExpression(theEnv,types,INSTANCE_ADDRESS,INSTANCE_ADDRESS,NULL);
if (rv->factAddressesAllowed)
types = GenTypeExpression(theEnv,types,FACT_ADDRESS,FACT_ADDRESS,NULL);
}
if (rv->multifieldsAllowed)
types = GenTypeExpression(theEnv,types,MULTIFIELD,MULTIFIELD,NULL);
}
RemoveConstraint(theEnv,rv);
PackRestrictionTypes(theEnv,rptr,types);
return(rptr);
}
globle int CheckArgumentAgainstRestriction(
struct expr *theExpression,
int theRestriction)
{
CONSTRAINT_RECORD *cr1, *cr2, *cr3;
/*=============================================*/
/* Generate a constraint record for the actual */
/* argument passed to the function. */
/*=============================================*/
cr1 = ExpressionToConstraintRecord(theExpression);
/*================================================*/
/* Generate a constraint record based on the type */
/* of argument expected by the function. */
/*================================================*/
cr2 = ArgumentTypeToConstraintRecord(theRestriction);
/*===============================================*/
/* Intersect the two constraint records and then */
/* discard them. */
/*===============================================*/
cr3 = IntersectConstraints(cr1,cr2);
RemoveConstraint(cr1);
RemoveConstraint(cr2);
/*====================================================*/
/* If the intersection of the two constraint records */
/* is empty, then the argument passed to the function */
/* doesn't satisfy the restrictions for the argument. */
/*====================================================*/
if (UnmatchableConstraint(cr3))
{
RemoveConstraint(cr3);
return(TRUE);
}
/*===================================================*/
/* The argument satisfies the function restrictions. */
/*===================================================*/
RemoveConstraint(cr3);
return(FALSE);
}
static BOOLEAN CheckArgumentForConstraintError(
struct expr *expressionList,
struct expr *lastOne,
int i,
struct FunctionDefinition *theFunction,
struct lhsParseNode *theLHS)
{
int theRestriction;
CONSTRAINT_RECORD *constraint1, *constraint2, *constraint3, *constraint4;
struct lhsParseNode *theVariable;
struct expr *tmpPtr;
int rv = FALSE;
/*=============================================================*/
/* Skip anything that isn't a variable or isn't an argument to */
/* a user defined function (i.e. deffunctions and generic have */
/* no constraint information so they aren't checked). */
/*=============================================================*/
if ((expressionList->type != SF_VARIABLE) || (theFunction == NULL))
{ return (rv); }
/*===========================================*/
/* Get the restrictions for the argument and */
/* convert them to a constraint record. */
/*===========================================*/
theRestriction = GetNthRestriction(theFunction,i);
constraint1 = ArgumentTypeToConstraintRecord(theRestriction);
/*================================================*/
/* Look for the constraint record associated with */
/* binding the variable in the LHS of the rule. */
/*================================================*/
theVariable = FindVariable((SYMBOL_HN *) expressionList->value,theLHS);
if (theVariable != NULL)
{
if (theVariable->type == MF_VARIABLE)
{
constraint2 = GetConstraintRecord();
SetConstraintType(MULTIFIELD,constraint2);
}
else if (theVariable->constraints == NULL)
{ constraint2 = GetConstraintRecord(); }
else
{ constraint2 = CopyConstraintRecord(theVariable->constraints); }
}
else
{ constraint2 = NULL; }
/*================================================*/
/* Look for the constraint record associated with */
/* binding the variable on the RHS of the rule. */
/*================================================*/
constraint3 = FindBindConstraints((SYMBOL_HN *) expressionList->value);
/*====================================================*/
/* Union the LHS and RHS variable binding constraints */
/* (the variable must satisfy one or the other). */
/*====================================================*/
constraint3 = UnionConstraints(constraint3,constraint2);
/*====================================================*/
/* Intersect the LHS/RHS variable binding constraints */
/* with the function argument restriction constraints */
/* (the variable must satisfy both). */
/*====================================================*/
constraint4 = IntersectConstraints(constraint3,constraint1);
/*====================================*/
/* Check for unmatchable constraints. */
/*====================================*/
if (UnmatchableConstraint(constraint4) && GetStaticConstraintChecking())
{
PrintErrorID("RULECSTR",3,TRUE);
PrintRouter(WERROR,"Previous variable bindings of ?");
PrintRouter(WERROR,ValueToString((SYMBOL_HN *) expressionList->value));
PrintRouter(WERROR," caused the type restrictions");
PrintRouter(WERROR,"\nfor argument #");
PrintLongInteger(WERROR,(long int) i);
PrintRouter(WERROR," of the expression ");
tmpPtr = lastOne->nextArg;
lastOne->nextArg = NULL;
PrintExpression(WERROR,lastOne);
lastOne->nextArg = tmpPtr;
PrintRouter(WERROR,"\nfound in the rule's RHS to be violated.\n");
rv = TRUE;
}
/*===========================================*/
/* Free the temporarily created constraints. */
/*===========================================*/
RemoveConstraint(constraint1);
RemoveConstraint(constraint2);
RemoveConstraint(constraint3);
RemoveConstraint(constraint4);
/*========================================*/
/* Return TRUE if unmatchable constraints */
/* were detected, otherwise FALSE. */
/*========================================*/
return(rv);
}
