/*******************************************************
NAME : CheckDeffunctionCall
DESCRIPTION : Checks the number of arguments
passed to a deffunction
INPUTS : 1) Deffunction pointer
2) The number of arguments
RETURNS : TRUE if OK, FALSE otherwise
SIDE EFFECTS : Message printed on errors
NOTES : None
*******************************************************/
globle int CheckDeffunctionCall(
void *theEnv,
void *vdptr,
int args)
{
DEFFUNCTION *dptr;
if (vdptr == NULL)
return(FALSE);
dptr = (DEFFUNCTION *) vdptr;
if (args < dptr->minNumberOfParameters)
{
if (dptr->maxNumberOfParameters == -1)
ExpectedCountError(theEnv,EnvGetDeffunctionName(theEnv,(void *) dptr),
AT_LEAST,dptr->minNumberOfParameters);
else
ExpectedCountError(theEnv,EnvGetDeffunctionName(theEnv,(void *) dptr),
EXACTLY,dptr->minNumberOfParameters);
return(FALSE);
}
else if ((args > dptr->minNumberOfParameters) &&
(dptr->maxNumberOfParameters != -1))
{
ExpectedCountError(theEnv,EnvGetDeffunctionName(theEnv,(void *) dptr),
EXACTLY,dptr->minNumberOfParameters);
return(FALSE);
}
return(TRUE);
}
void UnwatchCommand(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
UDFValue theValue;
const char *argument;
bool recognized;
WatchItemRecord *wPtr;
/*==========================================*/
/* Determine which item is to be unwatched. */
/*==========================================*/
if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue)) return;
argument = theValue.lexemeValue->contents;
wPtr = ValidWatchItem(theEnv,argument,&recognized);
if (recognized == false)
{
SetEvaluationError(theEnv,true);
UDFInvalidArgumentMessage(context,"watchable symbol");
return;
}
/*=================================================*/
/* Check to make sure extra arguments are allowed. */
/*=================================================*/
if (GetNextArgument(GetFirstArgument()) != NULL)
{
if ((wPtr == NULL) ? true : (wPtr->accessFunc == NULL))
{
SetEvaluationError(theEnv,true);
ExpectedCountError(theEnv,"unwatch",EXACTLY,1);
return;
}
}
/*=====================*/
/* Set the watch item. */
/*=====================*/
SetWatchItem(theEnv,argument,false,GetNextArgument(GetFirstArgument()));
}
globle void UnwatchCommand(
void *theEnv)
{
DATA_OBJECT theValue;
char *argument;
int recognized;
struct watchItem *wPtr;
/*==========================================*/
/* Determine which item is to be unwatched. */
/*==========================================*/
if (EnvArgTypeCheck(theEnv,"unwatch",1,SYMBOL,&theValue) == FALSE) return;
argument = DOToString(theValue);
wPtr = ValidWatchItem(theEnv,argument,&recognized);
if (recognized == FALSE)
{
SetEvaluationError(theEnv,TRUE);
ExpectedTypeError1(theEnv,"unwatch",1,"watchable symbol");
return;
}
/*=================================================*/
/* Check to make sure extra arguments are allowed. */
/*=================================================*/
if (GetNextArgument(GetFirstArgument()) != NULL)
{
if ((wPtr == NULL) ? TRUE : (wPtr->accessFunc == NULL))
{
SetEvaluationError(theEnv,TRUE);
ExpectedCountError(theEnv,"unwatch",EXACTLY,1);
return;
}
}
/*=====================*/
/* Set the watch item. */
/*=====================*/
EnvSetWatchItem(theEnv,argument,OFF,GetNextArgument(GetFirstArgument()));
}
globle int EnvArgCountCheck(
void *theEnv,
char *functionName,
int countRelation,
int expectedNumber)
{
int numberOfArguments;
/*==============================================*/
/* Get the number of arguments for the function */
/* currently being evaluated. */
/*==============================================*/
numberOfArguments = EnvRtnArgCount(theEnv);
/*=========================================================*/
/* If the function satisfies expected number of arguments, */
/* constraint, then return the number of arguments found. */
/*=========================================================*/
if (countRelation == EXACTLY)
{ if (numberOfArguments == expectedNumber) return(numberOfArguments); }
else if (countRelation == AT_LEAST)
{ if (numberOfArguments >= expectedNumber) return(numberOfArguments); }
else if (countRelation == NO_MORE_THAN)
{ if (numberOfArguments <= expectedNumber) return(numberOfArguments); }
/*================================================*/
/* The correct number of arguments was not found. */
/* Generate an error message and return -1. */
/*================================================*/
ExpectedCountError(theEnv,functionName,countRelation,expectedNumber);
SetHaltExecution(theEnv,TRUE);
SetEvaluationError(theEnv,TRUE);
return(-1);
}
/***********************************************************
NAME : ClassInfoFnxArgs
DESCRIPTION : Examines arguments for:
class-slots, get-defmessage-handler-list,
class-superclasses and class-subclasses
INPUTS : 1) Name of function
2) A buffer to hold a flag indicating if
the inherit keyword was specified
RETURNS : Pointer to the class on success,
NULL on errors
SIDE EFFECTS : inhp flag set
error flag set
NOTES : None
***********************************************************/
globle void *ClassInfoFnxArgs(
void *theEnv,
const char *fnx,
int *inhp)
{
void *clsptr;
DATA_OBJECT tmp;
*inhp = 0;
if (EnvRtnArgCount(theEnv) == 0)
{
ExpectedCountError(theEnv,fnx,AT_LEAST,1);
SetEvaluationError(theEnv,TRUE);
return(NULL);
}
if (EnvArgTypeCheck(theEnv,fnx,1,SYMBOL,&tmp) == FALSE)
return(NULL);
clsptr = (void *) LookupDefclassByMdlOrScope(theEnv,DOToString(tmp));
if (clsptr == NULL)
{
ClassExistError(theEnv,fnx,ValueToString(tmp.value));
return(NULL);
}
if (EnvRtnArgCount(theEnv) == 2)
{
if (EnvArgTypeCheck(theEnv,fnx,2,SYMBOL,&tmp) == FALSE)
return(NULL);
if (strcmp(ValueToString(tmp.value),"inherit") == 0)
*inhp = 1;
else
{
SyntaxErrorMessage(theEnv,fnx);
SetEvaluationError(theEnv,TRUE);
return(NULL);
}
}
return(clsptr);
}
globle char *GetConstructName(
void *theEnv,
char *functionName,
char *constructType)
{
DATA_OBJECT result;
if (EnvRtnArgCount(theEnv) != 1)
{
ExpectedCountError(theEnv,functionName,EXACTLY,1);
return(NULL);
}
EnvRtnUnknown(theEnv,1,&result);
if (GetType(result) != SYMBOL)
{
ExpectedTypeError1(theEnv,functionName,1,constructType);
return(NULL);
}
return(DOToString(result));
}
globle void ListWatchItemsCommand()
{
struct watchItem *wPtr;
DATA_OBJECT theValue;
int recognized;
/*=======================*/
/* List the watch items. */
/*=======================*/
if (GetFirstArgument() == NULL)
{
for (wPtr = ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
{
PrintRouter(WDISPLAY,wPtr->name);
if (*(wPtr->flag)) PrintRouter(WDISPLAY," = on\n");
else PrintRouter(WDISPLAY," = off\n");
}
return;
}
/*=======================================*/
/* Determine which item is to be listed. */
/*=======================================*/
if (ArgTypeCheck("list-watch-items",1,SYMBOL,&theValue) == FALSE) return;
wPtr = ValidWatchItem(DOToString(theValue),&recognized);
if ((recognized == FALSE) || (wPtr == NULL))
{
SetEvaluationError(TRUE);
ExpectedTypeError1("list-watch-items",1,"watchable symbol");
return;
}
/*=================================================*/
/* Check to make sure extra arguments are allowed. */
/*=================================================*/
if ((wPtr->printFunc == NULL) &&
(GetNextArgument(GetFirstArgument()) != NULL))
{
SetEvaluationError(TRUE);
ExpectedCountError("list-watch-items",EXACTLY,1);
return;
}
/*====================================*/
/* List the status of the watch item. */
/*====================================*/
PrintRouter(WDISPLAY,wPtr->name);
if (*(wPtr->flag)) PrintRouter(WDISPLAY," = on\n");
else PrintRouter(WDISPLAY," = off\n");
/*============================================*/
/* List the status of individual watch items. */
/*============================================*/
if (wPtr->printFunc != NULL)
{
if ((*wPtr->printFunc)(WDISPLAY,wPtr->code,
GetNextArgument(GetFirstArgument())) == FALSE)
{ SetEvaluationError(TRUE); }
}
}
globle intBool CheckFunctionArgCount(
void *theEnv,
char *functionName,
char *restrictions,
int argumentCount)
{
register int minArguments, maxArguments;
char theChar[2];
theChar[0] = '0';
theChar[1] = EOS;
/*=====================================================*/
/* If there are no restrictions, then there is no need */
/* to check for the correct number of arguments. */
/*=====================================================*/
if (restrictions == NULL) return(TRUE);
/*===========================================*/
/* Determine the minimum number of arguments */
/* required by the function. */
/*===========================================*/
if (isdigit(restrictions[0]))
{
theChar[0] = restrictions[0];
minArguments = atoi(theChar);
}
else
{ minArguments = -1; }
/*===========================================*/
/* Determine the maximum number of arguments */
/* required by the function. */
/*===========================================*/
if (isdigit(restrictions[1]))
{
theChar[0] = restrictions[1];
maxArguments = atoi(theChar);
}
else
{ maxArguments = 10000; }
/*==============================================*/
/* If the function expects exactly N arguments, */
/* then check to see if there are N arguments. */
/*==============================================*/
if (minArguments == maxArguments)
{
if (argumentCount != minArguments)
{
ExpectedCountError(theEnv,functionName,EXACTLY,minArguments);
SetEvaluationError(theEnv,TRUE);
return(FALSE);
}
return(TRUE);
}
/*==================================*/
/* Check to see if there were fewer */
/* arguments passed than expected. */
/*==================================*/
if (argumentCount < minArguments)
{
ExpectedCountError(theEnv,functionName,AT_LEAST,minArguments);
SetEvaluationError(theEnv,TRUE);
return(FALSE);
}
/*=================================*/
/* Check to see if there were more */
/* arguments passed than expected. */
/*=================================*/
if (argumentCount > maxArguments)
{
ExpectedCountError(theEnv,functionName,NO_MORE_THAN,maxArguments);
SetEvaluationError(theEnv,TRUE);
return(FALSE);
}
/*===============================*/
/* The number of arguments falls */
/* within the expected range. */
/*===============================*/
return(TRUE);
}
globle void ListWatchItemsCommand(
void *theEnv)
{
struct watchItem *wPtr;
DATA_OBJECT theValue;
int recognized;
/*=======================*/
/* List the watch items. */
/*=======================*/
if (GetFirstArgument() == NULL)
{
for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
{
EnvPrintRouter(theEnv,WDISPLAY,wPtr->name);
if (*(wPtr->flag)) EnvPrintRouter(theEnv,WDISPLAY,sym_equalson);
else EnvPrintRouter(theEnv,WDISPLAY,sym_equalsoff);
}
return;
}
/*=======================================*/
/* Determine which item is to be listed. */
/*=======================================*/
if (EnvArgTypeCheck(theEnv,name_listwatchitems,1,SYMBOL,&theValue) == FALSE) return;
wPtr = ValidWatchItem(theEnv,DOToString(theValue),&recognized);
if ((recognized == FALSE) || (wPtr == NULL))
{
SetEvaluationError(theEnv,TRUE);
ExpectedTypeError1(theEnv,name_listwatchitems,1,sym_watchable_symbol);
return;
}
/*=================================================*/
/* Check to make sure extra arguments are allowed. */
/*=================================================*/
if ((wPtr->printFunc == NULL) &&
(GetNextArgument(GetFirstArgument()) != NULL))
{
SetEvaluationError(theEnv,TRUE);
ExpectedCountError(theEnv,name_listwatchitems,EXACTLY,1);
return;
}
/*====================================*/
/* List the status of the watch item. */
/*====================================*/
EnvPrintRouter(theEnv,WDISPLAY,wPtr->name);
if (*(wPtr->flag)) EnvPrintRouter(theEnv,WDISPLAY,sym_equalson);
else EnvPrintRouter(theEnv,WDISPLAY,sym_equalsoff);
/*============================================*/
/* List the status of individual watch items. */
/*============================================*/
if (wPtr->printFunc != NULL)
{
if ((*wPtr->printFunc)(theEnv,WDISPLAY,wPtr->code,
GetNextArgument(GetFirstArgument())) == FALSE)
{ SetEvaluationError(theEnv,TRUE); }
}
}
void ListWatchItemsCommand(
Environment *theEnv,
UDFContext *context,
UDFValue *returnValue)
{
WatchItemRecord *wPtr;
UDFValue theValue;
bool recognized;
/*=======================*/
/* List the watch items. */
/*=======================*/
if (GetFirstArgument() == NULL)
{
for (wPtr = WatchData(theEnv)->ListOfWatchItems; wPtr != NULL; wPtr = wPtr->next)
{
WriteString(theEnv,STDOUT,wPtr->name);
if (*(wPtr->flag)) WriteString(theEnv,STDOUT," = on\n");
else WriteString(theEnv,STDOUT," = off\n");
}
return;
}
/*=======================================*/
/* Determine which item is to be listed. */
/*=======================================*/
if (! UDFFirstArgument(context,SYMBOL_BIT,&theValue)) return;
wPtr = ValidWatchItem(theEnv,theValue.lexemeValue->contents,&recognized);
if ((recognized == false) || (wPtr == NULL))
{
SetEvaluationError(theEnv,true);
ExpectedTypeError1(theEnv,"list-watch-items",1,"'watchable symbol'");
return;
}
/*=================================================*/
/* Check to make sure extra arguments are allowed. */
/*=================================================*/
if ((wPtr->printFunc == NULL) &&
(GetNextArgument(GetFirstArgument()) != NULL))
{
SetEvaluationError(theEnv,true);
ExpectedCountError(theEnv,"list-watch-items",EXACTLY,1);
return;
}
/*====================================*/
/* List the status of the watch item. */
/*====================================*/
WriteString(theEnv,STDOUT,wPtr->name);
if (*(wPtr->flag)) WriteString(theEnv,STDOUT," = on\n");
else WriteString(theEnv,STDOUT," = off\n");
/*============================================*/
/* List the status of individual watch items. */
/*============================================*/
if (wPtr->printFunc != NULL)
{
if ((*wPtr->printFunc)(theEnv,STDOUT,wPtr->code,
GetNextArgument(GetFirstArgument())) == false)
{ SetEvaluationError(theEnv,true); }
}
}
globle int CheckExpressionAgainstRestrictions(
void *theEnv,
struct expr *theExpression,
char *restrictions,
char *functionName)
{
char theChar[2];
int i = 0, j = 1;
int number1, number2;
int argCount;
char defaultRestriction, argRestriction;
struct expr *argPtr;
int theRestriction;
theChar[0] = '0';
theChar[1] = '\0';
/*============================================*/
/* If there are no restrictions, then there's */
/* no need to check the function. */
/*============================================*/
if (restrictions == NULL) return(FALSE);
/*=========================================*/
/* Count the number of function arguments. */
/*=========================================*/
argCount = CountArguments(theExpression->argList);
/*======================================*/
/* Get the minimum number of arguments. */
/*======================================*/
theChar[0] = restrictions[i++];
if (isdigit(theChar[0]))
{ number1 = atoi(theChar); }
else if (theChar[0] == '*')
{ number1 = -1; }
else
{ return(FALSE); }
/*======================================*/
/* Get the maximum number of arguments. */
/*======================================*/
theChar[0] = restrictions[i++];
if (isdigit(theChar[0]))
{ number2 = atoi(theChar); }
else if (theChar[0] == '*')
{ number2 = 10000; }
else
{ return(FALSE); }
/*============================================*/
/* Check for the correct number of arguments. */
/*============================================*/
if (number1 == number2)
{
if (argCount != number1)
{
ExpectedCountError(theEnv,functionName,EXACTLY,number1);
return(TRUE);
}
}
else if (argCount < number1)
{
ExpectedCountError(theEnv,functionName,AT_LEAST,number1);
return(TRUE);
}
else if (argCount > number2)
{
ExpectedCountError(theEnv,functionName,NO_MORE_THAN,number2);
return(TRUE);
}
/*=======================================*/
/* Check for the default argument types. */
/*=======================================*/
defaultRestriction = restrictions[i];
if (defaultRestriction == '\0')
{ defaultRestriction = 'u'; }
else if (defaultRestriction == '*')
{
defaultRestriction = 'u';
i++;
}
else
{ i++; }
/*======================*/
/* Check each argument. */
/*======================*/
for (argPtr = theExpression->argList;
argPtr != NULL;
argPtr = argPtr->nextArg)
{
argRestriction = restrictions[i];
if (argRestriction == '\0')
{ argRestriction = defaultRestriction; }
else
{ i++; }
if (argRestriction != '*')
{ theRestriction = (int) argRestriction; }
else
{ theRestriction = (int) defaultRestriction; }
if (CheckArgumentAgainstRestriction(theEnv,argPtr,theRestriction))
{
ExpectedTypeError1(theEnv,functionName,j,GetArgumentTypeName(theRestriction));
return(TRUE);
}
j++;
}
return(FALSE);
}
bool CheckFunctionArgCount(
Environment *theEnv,
struct functionDefinition *func,
int argumentCount)
{
unsigned short minArguments, maxArguments;
const char *functionName;
functionName = func->callFunctionName->contents;
/*===========================================*/
/* Determine the minimum number of arguments */
/* required by the function. */
/*===========================================*/
minArguments = func->minArgs;
/*===========================================*/
/* Determine the maximum number of arguments */
/* required by the function. */
/*===========================================*/
maxArguments = func->maxArgs;
/*=====================================*/
/* If the function has no restrictions */
/* on function arguments, return true. */
/*=====================================*/
if ((minArguments == UNBOUNDED) && (maxArguments == UNBOUNDED))
{ return true; }
/*==============================================*/
/* If the function expects exactly N arguments, */
/* then check to see if there are N arguments. */
/*==============================================*/
if (minArguments == maxArguments)
{
if (argumentCount != minArguments)
{
ExpectedCountError(theEnv,functionName,EXACTLY,minArguments);
SetEvaluationError(theEnv,true);
return false;
}
return true;
}
/*==================================*/
/* Check to see if there were fewer */
/* arguments passed than expected. */
/*==================================*/
if (argumentCount < minArguments)
{
ExpectedCountError(theEnv,functionName,AT_LEAST,minArguments);
SetEvaluationError(theEnv,true);
return false;
}
/*=================================*/
/* Check to see if there were more */
/* arguments passed than expected. */
/*=================================*/
if ((maxArguments != UNBOUNDED) && (argumentCount > maxArguments))
{
ExpectedCountError(theEnv,functionName,NO_MORE_THAN,maxArguments);
SetEvaluationError(theEnv,true);
return false;
}
/*===============================*/
/* The number of arguments falls */
/* within the expected range. */
/*===============================*/
return true;
}
