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,name_unwatch,1,SYMBOL,&theValue) == FALSE) return;
argument = DOToString(theValue);
wPtr = ValidWatchItem(theEnv,argument,&recognized);
if (recognized == FALSE)
{
SetEvaluationError(theEnv,TRUE);
ExpectedTypeError1(theEnv,name_unwatch,1,sym_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,name_unwatch,EXACTLY,1);
return;
}
}
/*=====================*/
/* Set the watch item. */
/*=====================*/
EnvSetWatchItem(theEnv,argument,OFF,GetNextArgument(GetFirstArgument()));
}
/////////////////////////////////////////////////////////////////////////////
// VerifyFileSignature
//
DWORD VerifyFileSignature (LPCSTR lpszModule, __in_opt LPSTR lpszCmdLine)
{
LPCSTR pszFirstArgEnd;
LPCSTR pszFileName;
LPCSTR pszEnd;
DWORD Status;
//
// When this function is called, the first argument has already
// been verified. So skip the first argument.
//
GetNextArgument (lpszCmdLine, NULL, &pszFirstArgEnd, NULL);
// Now get the name of the file whose signature needs to be verified.
Status = GetNextArgument (CharNextA(pszFirstArgEnd), &pszFileName, &pszEnd, NULL);
// Must supply a filename
if (ERROR_NO_MORE_ITEMS == Status)
return ERROR_BAD_ARGUMENTS;
// Should not have any more arguments
if ('\0' != *(CharNextA(pszEnd)) &&
ERROR_NO_MORE_ITEMS != GetNextArgument (CharNextA(CharNextA(pszEnd)), NULL, NULL, NULL))
{
return ERROR_BAD_ARGUMENTS;
}
// We have the right arguments. Null terminate the filename.
*(CharNextA(pszEnd)) = '\0';
switch (IsPackageTrusted(lpszModule, pszFileName, NULL))
{
case itvWintrustNotOnMachine:
return TRUST_E_PROVIDER_UNKNOWN;
case itvTrusted:
return ERROR_SUCCESS;
case itvUnTrusted:
default:
return TRUST_E_SUBJECT_NOT_TRUSTED;
}
}
globle intBool AndFunction(
void *theEnv)
{
EXPRESSION *theArgument;
DATA_OBJECT result;
for (theArgument = GetFirstArgument();
theArgument != NULL;
theArgument = GetNextArgument(theArgument))
{
if (EvaluateExpression(theEnv,theArgument,&result)) return(FALSE);
if ((result.value == EnvFalseSymbol(theEnv)) && (result.type == SYMBOL))
{ return(FALSE); }
}
return(TRUE);
}
globle intBool OrFunction(
void *theEnv,
EXEC_STATUS)
{
EXPRESSION *theArgument;
DATA_OBJECT result;
for (theArgument = GetFirstArgument();
theArgument != NULL;
theArgument = GetNextArgument(theArgument))
{
if (EvaluateExpression(theEnv,execStatus,theArgument,&result)) return(FALSE);
if ((result.value != EnvFalseSymbol(theEnv,execStatus)) || (result.type != SYMBOL))
{ return(TRUE); }
}
return(FALSE);
}
/////////////////////////////////////////////////////////////////////////////
// GetExecutionMode
//
emEnum GetExecutionMode (LPCSTR lpszCmdLine)
{
LPCSTR pszStart = NULL;
LPCSTR pszEnd = NULL;
DWORD dwStatus = ERROR_SUCCESS;
bool fQuoted = false;
//
// Check the first argument and set the execution mode accordingly.
// When run without arguments, it is assumed that the default install
// preset by the package publisher needs to be performed.
//
// In case an invalid option is provided, the help dialog describing the
// usage must be displayed.
//
dwStatus = GetNextArgument (lpszCmdLine, &pszStart, &pszEnd, &fQuoted);
if (ERROR_NO_MORE_ITEMS == dwStatus)
return emPreset;
// The only allowed values in the first argument are /a, /v and /?
if (pszEnd != CharNextA(pszStart) || fQuoted)
return emHelp;
if ('/' != (*pszStart) && '-' != (*pszStart))
return emHelp;
switch (*pszEnd)
{
case 'a':
case 'A':
return emAdminInstall;
case 'v':
case 'V':
return emVerify;
default:
return emHelp;
}
}
globle long DivFunction(
void *theEnv)
{
long total = 1L;
EXPRESSION *theExpression;
DATA_OBJECT theArgument;
int pos = 1;
long theNumber;
/*===================================================*/
/* Get the first argument. This number which will be */
/* the starting product from which all subsequent */
/* arguments will divide. */
/*===================================================*/
theExpression = GetFirstArgument();
if (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"div",&theArgument,FALSE,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if (theArgument.type == INTEGER)
{ total = ValueToLong(theArgument.value); }
else
{ total = (long) ValueToDouble(theArgument.value); }
pos++;
}
/*=====================================================*/
/* Loop through each of the arguments dividing it into */
/* a running product. Floats are converted to integers */
/* and each argument is checked to prevent a divide by */
/* zero error. */
/*=====================================================*/
while (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"div",&theArgument,FALSE,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if (theArgument.type == INTEGER) theNumber = ValueToLong(theArgument.value);
else if (theArgument.type == FLOAT) theNumber = (long) ValueToDouble(theArgument.value);
else theNumber = 1;
if (theNumber == 0L)
{
DivideByZeroErrorMessage(theEnv,"div");
SetHaltExecution(theEnv,TRUE);
SetEvaluationError(theEnv,TRUE);
return(1L);
}
if (theArgument.type == INTEGER)
{ total /= ValueToLong(theArgument.value); }
else
{ total = total / (long) ValueToDouble(theArgument.value); }
pos++;
}
/*======================================================*/
/* The result of the div function is always an integer. */
/*======================================================*/
return(total);
}
globle void DivisionFunction(
void *theEnv,
DATA_OBJECT_PTR returnValue)
{
double ftotal = 1.0;
long ltotal = 1L;
intBool useFloatTotal;
EXPRESSION *theExpression;
DATA_OBJECT theArgument;
int pos = 1;
useFloatTotal = BasicMathFunctionData(theEnv)->AutoFloatDividend;
/*===================================================*/
/* Get the first argument. This number which will be */
/* the starting product from which all subsequent */
/* arguments will divide. If the auto float dividend */
/* feature is enable, then this number is converted */
/* to a float if it is an integer. */
/*===================================================*/
theExpression = GetFirstArgument();
if (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"/",&theArgument,useFloatTotal,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if (theArgument.type == INTEGER)
{ ltotal = ValueToLong(theArgument.value); }
else
{
ftotal = ValueToDouble(theArgument.value);
useFloatTotal = TRUE;
}
pos++;
}
/*====================================================*/
/* Loop through each of the arguments dividing it */
/* into a running product. If a floating point number */
/* is encountered, then do all subsequent operations */
/* using floating point values. Each argument is */
/* checked to prevent a divide by zero error. */
/*====================================================*/
while (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"/",&theArgument,useFloatTotal,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if ((theArgument.type == INTEGER) ? (ValueToLong(theArgument.value) == 0L) :
((theArgument.type == FLOAT) ? ValueToDouble(theArgument.value) == 0.0 : FALSE))
{
DivideByZeroErrorMessage(theEnv,"/");
SetHaltExecution(theEnv,TRUE);
SetEvaluationError(theEnv,TRUE);
returnValue->type = FLOAT;
returnValue->value = (void *) EnvAddDouble(theEnv,1.0);
return;
}
if (useFloatTotal)
{ ftotal /= ValueToDouble(theArgument.value); }
else
{
if (theArgument.type == INTEGER)
{ ltotal /= ValueToLong(theArgument.value); }
else
{
ftotal = (double) ltotal / ValueToDouble(theArgument.value);
useFloatTotal = TRUE;
}
}
pos++;
}
/*======================================================*/
/* If a floating point number was in the argument list, */
/* then return a float, otherwise return an integer. */
/*======================================================*/
if (useFloatTotal)
{
returnValue->type = FLOAT;
returnValue->value = (void *) EnvAddDouble(theEnv,ftotal);
}
else
{
returnValue->type = INTEGER;
returnValue->value = (void *) EnvAddLong(theEnv,ltotal);
}
}
globle void SubtractionFunction(
void *theEnv,
DATA_OBJECT_PTR returnValue)
{
double ftotal = 0.0;
long ltotal = 0L;
intBool useFloatTotal = FALSE;
EXPRESSION *theExpression;
DATA_OBJECT theArgument;
int pos = 1;
/*=================================================*/
/* Get the first argument. This number which will */
/* be the starting total from which all subsequent */
/* arguments will subtracted. */
/*=================================================*/
theExpression = GetFirstArgument();
if (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"-",&theArgument,useFloatTotal,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if (theArgument.type == INTEGER)
{ ltotal = ValueToLong(theArgument.value); }
else
{
ftotal = ValueToDouble(theArgument.value);
useFloatTotal = TRUE;
}
pos++;
}
/*===================================================*/
/* Loop through each of the arguments subtracting it */
/* from a running total. If a floating point number */
/* is encountered, then do all subsequent operations */
/* using floating point values. */
/*===================================================*/
while (theExpression != NULL)
{
if (! GetNumericArgument(theEnv,theExpression,"-",&theArgument,useFloatTotal,pos)) theExpression = NULL;
else theExpression = GetNextArgument(theExpression);
if (useFloatTotal)
{ ftotal -= ValueToDouble(theArgument.value); }
else
{
if (theArgument.type == INTEGER)
{ ltotal -= ValueToLong(theArgument.value); }
else
{
ftotal = (double) ltotal - ValueToDouble(theArgument.value);
useFloatTotal = TRUE;
}
}
pos++;
}
/*======================================================*/
/* If a floating point number was in the argument list, */
/* then return a float, otherwise return an integer. */
/*======================================================*/
if (useFloatTotal)
{
returnValue->type = FLOAT;
returnValue->value = (void *) EnvAddDouble(theEnv,ftotal);
}
else
{
returnValue->type = INTEGER;
returnValue->value = (void *) EnvAddLong(theEnv,ltotal);
}
}
globle void RetractCommand(
void *theEnv)
{
long long factIndex;
struct fact *ptr;
struct expr *theArgument;
DATA_OBJECT theResult;
int argNumber;
/*================================*/
/* Iterate through each argument. */
/*================================*/
for (theArgument = GetFirstArgument(), argNumber = 1;
theArgument != NULL;
theArgument = GetNextArgument(theArgument), argNumber++)
{
/*========================*/
/* Evaluate the argument. */
/*========================*/
EvaluateExpression(theEnv,theArgument,&theResult);
/*===============================================*/
/* If the argument evaluates to an integer, then */
/* it's assumed to be the fact index of the fact */
/* to be retracted. */
/*===============================================*/
if (theResult.type == INTEGER)
{
/*==========================================*/
/* A fact index must be a positive integer. */
/*==========================================*/
factIndex = ValueToLong(theResult.value);
if (factIndex < 0)
{
ExpectedTypeError1(theEnv,(char*)"retract",argNumber,(char*)"fact-address, fact-index, or the symbol *");
return;
}
/*================================================*/
/* See if a fact with the specified index exists. */
/*================================================*/
ptr = FindIndexedFact(theEnv,factIndex);
/*=====================================*/
/* If the fact exists then retract it, */
/* otherwise print an error message. */
/*=====================================*/
if (ptr != NULL)
{ EnvRetract(theEnv,(void *) ptr); }
else
{
char tempBuffer[20];
gensprintf(tempBuffer,"f-%lld",factIndex);
CantFindItemErrorMessage(theEnv,(char*)"fact",tempBuffer);
}
}
/*===============================================*/
/* Otherwise if the argument evaluates to a fact */
/* address, we can directly retract it. */
/*===============================================*/
else if (theResult.type == FACT_ADDRESS)
{ EnvRetract(theEnv,theResult.value); }
/*============================================*/
/* Otherwise if the argument evaluates to the */
/* symbol *, then all facts are retracted. */
/*============================================*/
else if ((theResult.type == SYMBOL) ?
(strcmp(ValueToString(theResult.value),"*") == 0) : FALSE)
{
RemoveAllFacts(theEnv);
return;
}
/*============================================*/
/* Otherwise the argument has evaluated to an */
/* illegal value for the retract command. */
/*============================================*/
else
{
ExpectedTypeError1(theEnv,(char*)"retract",argNumber,(char*)"fact-address, fact-index, or the symbol *");
SetEvaluationError(theEnv,TRUE);
}
}
}
/*
*******************************************************************
* Function: int CGBLBuildCommand::DoHandleNextLocalArgument (const CKBehaviorContext& behaviorContext)
*
* Description : Checks if there are more arguments to be specified for global command
* and takes corresponded actions
*
* Parameters :
* behaviourContext r Behavior context reference, which gives
* access to frequently used global objects
* ( context, level, manager, etc... )
*
*******************************************************************
*/
int CGBLBuildCommand::DoHandleNextLocalArgument (const CKBehaviorContext& behaviorContext)
{
CKBehavior* behavior = behaviorContext.Behavior;
CKContext* context = behaviorContext.Context;
int gblBuildCommandState;
CKBehavior* targetBB = NULL;
CK_ID targetID;
behavior->GetLocalParameterValue (targetBBLocalPos, &targetID);
targetBB = (CKBehavior*)behaviorContext.Context->GetObject(targetID);
if (targetBB == NULL)
{
CKParameterOut *parameterOutError = behavior->GetOutputParameter(EGBLBuildCommandParamOutputs::GetError);
TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLFC_ERROR_BUILDCOMMAND_TARGET_NOT_FOUND,GBLFC_ERROR_BUILDCOMMAND_TARGET_NOT_FOUND_DESC);
behavior->ActivateOutput (EGBLBuildCommandBehOutputs::Error);
return CKBR_OK;
}
int currentParameterPosition = 0;
behavior->GetLocalParameterValue (currentParameterPositionLocalPos, ¤tParameterPosition);
CKParameter* nextArgument = CGBLCommandUtil::GetCommandArgument(*targetBB, currentParameterPosition);
currentParameterPosition++;
behavior->SetLocalParameterValue (currentParameterPositionLocalPos, ¤tParameterPosition);
if (nextArgument == NULL)
{
//no arguments required, build finished
//char commandString[512];
//behavior->GetLocalParameterValue(commandStringLocalPos,&commandString);
CKSTRING commandString = (CKSTRING) behavior->GetLocalParameter(commandStringLocalPos)->GetReadDataPtr();
int res = CGBLCommandUtil::InvokeCommand (commandString, behaviorContext);
ClearParameterOutputs(behaviorContext);
if (res != CK_OK)
{
CKParameterOut *parameterOutError = behavior->GetOutputParameter(EGBLBuildCommandParamOutputs::GetError);
TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLFC_ERROR_BUILDCOMMAND_INVOKING_FAILED, GBLFC_ERROR_BUILDCOMMAND_INVOKING_FAILED_DESC);
behavior->ActivateOutput (EGBLBuildCommandBehOutputs::Error);
return CKBR_OK;
}
behavior->ActivateOutput (EGBLBuildCommandBehOutputs::HandleUntargetedCommand);
return CKBR_OK;
}
else
{
//get next argument
gblBuildCommandState = EGBLBuildCommandState::AwaitingParametersForUntargeted;
behavior->SetLocalParameterValue (gblBuildCommandStateLocalPos, &gblBuildCommandState);
GetNextArgument (nextArgument, targetBB, behaviorContext);
return CKBR_OK;
}
}
globle intBool NumericNotEqualFunction(
void *theEnv,
EXEC_STATUS)
{
EXPRESSION *theArgument;
DATA_OBJECT rv1, rv2;
int pos = 1;
/*=========================*/
/* Get the first argument. */
/*=========================*/
theArgument = GetFirstArgument();
if (theArgument == NULL) { return(TRUE); }
if (! GetNumericArgument(theEnv,execStatus,theArgument,"<>",&rv1,FALSE,pos)) return(FALSE);
pos++;
/*=================================================*/
/* Compare each of the subsequent arguments to the */
/* first. If any is equal, then return FALSE. */
/*=================================================*/
for (theArgument = GetNextArgument(theArgument);
theArgument != NULL;
theArgument = GetNextArgument(theArgument), pos++)
{
if (! GetNumericArgument(theEnv,execStatus,theArgument,"<>",&rv2,FALSE,pos)) return(FALSE);
if (rv1.type == INTEGER)
{
if (rv2.type == INTEGER)
{
if (ValueToLong(rv1.value) == ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if ((double) ValueToLong(rv1.value) == ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
else
{
if (rv2.type == INTEGER)
{
if (ValueToDouble(rv1.value) == (double) ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if (ValueToDouble(rv1.value) == ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
}
/*===================================*/
/* All arguments were unequal to the */
/* first argument. Return TRUE. */
/*===================================*/
return(TRUE);
}
globle intBool LessThanOrEqualFunction(
void *theEnv)
{
EXPRESSION *theArgument;
DATA_OBJECT rv1, rv2;
int pos = 1;
/*=========================*/
/* Get the first argument. */
/*=========================*/
theArgument = GetFirstArgument();
if (theArgument == NULL) { return(TRUE); }
if (! GetNumericArgument(theEnv,theArgument,"<=",&rv1,FALSE,pos)) return(FALSE);
pos++;
/*====================================================*/
/* Compare each of the subsequent arguments to its */
/* predecessor. If any is greater, then return FALSE. */
/*====================================================*/
for (theArgument = GetNextArgument(theArgument);
theArgument != NULL;
theArgument = GetNextArgument(theArgument), pos++)
{
if (! GetNumericArgument(theEnv,theArgument,"<=",&rv2,FALSE,pos)) return(FALSE);
if (rv1.type == INTEGER)
{
if (rv2.type == INTEGER)
{
if (ValueToLong(rv1.value) > ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if ((double) ValueToLong(rv1.value) > ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
else
{
if (rv2.type == INTEGER)
{
if (ValueToDouble(rv1.value) > (double) ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if (ValueToDouble(rv1.value) > ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
rv1.type = rv2.type;
rv1.value = rv2.value;
}
/*======================================*/
/* Each argument was less than or equal */
/* to it predecessor. Return TRUE. */
/*======================================*/
return(TRUE);
}
/*********************************************************************
NAME : ParseDefinstances
DESCRIPTION : Parses and allocates a definstances construct
INPUTS : The logical name of the input source
RETURNS : FALSE if no errors, TRUE otherwise
SIDE EFFECTS : Definstances parsed and created
NOTES : H/L Syntax :
(definstances <name> [active] [<comment>]
<instance-definition>+)
<instance-definition> ::=
(<instance-name> of <class-name> <slot-override>*)
<slot-override> ::= (<slot-name> <value-expression>*)
*********************************************************************/
static int ParseDefinstances(
void *theEnv,
char *readSource)
{
SYMBOL_HN *dname;
void *mkinsfcall;
EXPRESSION *mkinstance,*mkbot = NULL;
DEFINSTANCES *dobj;
int active;
SetPPBufferStatus(theEnv,ON);
FlushPPBuffer(theEnv);
SetIndentDepth(theEnv,3);
SavePPBuffer(theEnv,(char*)"(definstances ");
#if BLOAD || BLOAD_AND_BSAVE
if ((Bloaded(theEnv)) && (! ConstructData(theEnv)->CheckSyntaxMode))
{
CannotLoadWithBloadMessage(theEnv,(char*)"definstances");
return(TRUE);
}
#endif
dname = ParseDefinstancesName(theEnv,readSource,&active);
if (dname == NULL)
return(TRUE);
dobj = get_struct(theEnv,definstances);
InitializeConstructHeader(theEnv,(char*)"definstances",(struct constructHeader *) dobj,dname);
dobj->busy = 0;
dobj->mkinstance = NULL;
#if DEFRULE_CONSTRUCT
if (active)
mkinsfcall = (void *) FindFunction(theEnv,(char*)"active-make-instance");
else
mkinsfcall = (void *) FindFunction(theEnv,(char*)"make-instance");
#else
mkinsfcall = (void *) FindFunction(theEnv,(char*)"make-instance");
#endif
while (GetType(DefclassData(theEnv)->ObjectParseToken) == LPAREN)
{
mkinstance = GenConstant(theEnv,UNKNOWN_VALUE,mkinsfcall);
mkinstance = ParseInitializeInstance(theEnv,mkinstance,readSource);
if (mkinstance == NULL)
{
ReturnExpression(theEnv,dobj->mkinstance);
rtn_struct(theEnv,definstances,dobj);
return(TRUE);
}
if (ExpressionContainsVariables(mkinstance,FALSE) == TRUE)
{
LocalVariableErrorMessage(theEnv,(char*)"definstances");
ReturnExpression(theEnv,mkinstance);
ReturnExpression(theEnv,dobj->mkinstance);
rtn_struct(theEnv,definstances,dobj);
return(TRUE);
}
if (mkbot == NULL)
dobj->mkinstance = mkinstance;
else
GetNextArgument(mkbot) = mkinstance;
mkbot = mkinstance;
GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);
PPBackup(theEnv);
PPCRAndIndent(theEnv);
SavePPBuffer(theEnv,DefclassData(theEnv)->ObjectParseToken.printForm);
}
if (GetType(DefclassData(theEnv)->ObjectParseToken) != RPAREN)
{
ReturnExpression(theEnv,dobj->mkinstance);
rtn_struct(theEnv,definstances,dobj);
SyntaxErrorMessage(theEnv,(char*)"definstances");
return(TRUE);
}
else
{
if (ConstructData(theEnv)->CheckSyntaxMode)
{
ReturnExpression(theEnv,dobj->mkinstance);
rtn_struct(theEnv,definstances,dobj);
return(FALSE);
}
#if DEBUGGING_FUNCTIONS
if (EnvGetConserveMemory(theEnv) == FALSE)
{
if (dobj->mkinstance != NULL)
PPBackup(theEnv);
PPBackup(theEnv);
SavePPBuffer(theEnv,(char*)")\n");
SetDefinstancesPPForm((void *) dobj,CopyPPBuffer(theEnv));
}
#endif
mkinstance = dobj->mkinstance;
dobj->mkinstance = PackExpression(theEnv,mkinstance);
ReturnExpression(theEnv,mkinstance);
IncrementSymbolCount(GetDefinstancesNamePointer((void *) dobj));
ExpressionInstall(theEnv,dobj->mkinstance);
}
AddConstructToModule((struct constructHeader *) dobj);
return(FALSE);
}
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); }
}
}
/*******************************************************
NAME : DefmessageHandlerWatchSupport
DESCRIPTION : Sets or displays handlers specified
INPUTS : 1) The calling function name
2) The logical output name for displays
(can be NULL)
4) The new set state (can be -1)
5) The print function (can be NULL)
6) The trace function (can be NULL)
7) The handlers expression list
RETURNS : TRUE if all OK,
FALSE otherwise
SIDE EFFECTS : Handler trace flags set or displayed
NOTES : None
*******************************************************/
static unsigned DefmessageHandlerWatchSupport(
void *theEnv,
const char *funcName,
const char *logName,
int newState,
void (*printFunc)(void *,const char *,void *,int),
void (*traceFunc)(void *,int,void *,int),
EXPRESSION *argExprs)
{
struct defmodule *theModule;
void *theClass;
const char *theHandlerStr;
int theType;
int argIndex = 2;
DATA_OBJECT tmpData;
/* ===============================
If no handlers are specified,
show the trace for all handlers
in all handlers
=============================== */
if (argExprs == NULL)
{
SaveCurrentModule(theEnv);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
EnvSetCurrentModule(theEnv,(void *) theModule);
if (traceFunc == NULL)
{
EnvPrintRouter(theEnv,logName,EnvGetDefmoduleName(theEnv,(void *) theModule));
EnvPrintRouter(theEnv,logName,":\n");
}
theClass = EnvGetNextDefclass(theEnv,NULL);
while (theClass != NULL)
{
if (WatchClassHandlers(theEnv,theClass,NULL,-1,logName,newState,
TRUE,printFunc,traceFunc) == FALSE)
return(FALSE);
theClass = EnvGetNextDefclass(theEnv,theClass);
}
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
RestoreCurrentModule(theEnv);
return(TRUE);
}
/* ================================================
Set or show the traces for the specified handler
================================================ */
while (argExprs != NULL)
{
if (EvaluateExpression(theEnv,argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(theEnv,funcName,argIndex,"class name");
return(FALSE);
}
theClass = (void *) LookupDefclassByMdlOrScope(theEnv,DOToString(tmpData));
if (theClass == NULL)
{
ExpectedTypeError1(theEnv,funcName,argIndex,"class name");
return(FALSE);
}
if (GetNextArgument(argExprs) != NULL)
{
argExprs = GetNextArgument(argExprs);
argIndex++;
if (EvaluateExpression(theEnv,argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(theEnv,funcName,argIndex,"handler name");
return(FALSE);
}
theHandlerStr = DOToString(tmpData);
if (GetNextArgument(argExprs) != NULL)
{
argExprs = GetNextArgument(argExprs);
argIndex++;
if (EvaluateExpression(theEnv,argExprs,&tmpData))
return(FALSE);
if (tmpData.type != SYMBOL)
{
ExpectedTypeError1(theEnv,funcName,argIndex,"handler type");
return(FALSE);
}
if ((theType = (int) HandlerType(theEnv,funcName,DOToString(tmpData))) == MERROR)
return(FALSE);
}
else
theType = -1;
}
else
{
theHandlerStr = NULL;
theType = -1;
}
if (WatchClassHandlers(theEnv,theClass,theHandlerStr,theType,logName,
newState,FALSE,printFunc,traceFunc) == FALSE)
{
ExpectedTypeError1(theEnv,funcName,argIndex,"handler");
return(FALSE);
}
argIndex++;
argExprs = GetNextArgument(argExprs);
}
return(TRUE);
}
globle void MultiplicationFunction(
void *theEnv,
DATA_OBJECT_PTR returnValue)
{
double ftotal = 1.0;
double ftmp = 0.0;
long long ltotal = 1LL;
long long ltmp = 0LL;
intBool useFloatTotal = FALSE;
EXPRESSION *theExpression;
DATA_OBJECT theArgument;
int pos = 1;
/*===================================================*/
/* Loop through each of the arguments multiplying it */
/* by a running product. If a floating point number */
/* is encountered, then do all subsequent operations */
/* using floating point values. */
/*===================================================*/
theExpression = GetFirstArgument();
while (theExpression != NULL) {
if (! GetNumericArgument(theEnv,theExpression,"*",&theArgument,useFloatTotal,pos))
theExpression = NULL;
else
theExpression = GetNextArgument(theExpression);
if (useFloatTotal) {
ftmp = ValueToDouble(theArgument.value);
if(ftmp == 0.0) {
ftotal = 0.0;
break;
} else if(ftmp != 1.0) {
ftotal *= ftmp;
}
} else {
if (theArgument.type == INTEGER) {
ltmp = ValueToLong(theArgument.value);
if(ltmp == 0LL) {
ltotal = 0LL;
break;
} else if (ltmp != 1LL) {
/* We shouldn't waste time handling multiplication by one */
ltotal *= ltmp;
}
} else {
ftmp = ValueToDouble(theArgument.value);
if(ftmp == 0.0) {
ftotal = 0.0;
break;
} else if(ftmp == 1.0) {
/* just cast as a double instead of wasting a multiply */
ftotal = (double) ltotal;
} else {
ftotal = (double) ltotal * ftmp;
}
useFloatTotal = TRUE;
}
}
pos++;
}
/*======================================================*/
/* If a floating point number was in the argument list, */
/* then return a float, otherwise return an integer. */
/*======================================================*/
if (useFloatTotal) {
returnValue->type = FLOAT;
returnValue->value = (void *) EnvAddDouble(theEnv,ftotal);
} else {
returnValue->type = INTEGER;
returnValue->value = (void *) EnvAddLong(theEnv,ltotal);
}
}
/**
* @brief Parse function expression
*/
ParsedFunction
ParseFunction(const char *value, bool argistype)
{
int i;
ParsedFunction ret;
char *buf;
const char *nextp;
bool done = false;
List *names;
ListCell *l;
int nargs;
FuncCandidateList candidates;
FuncCandidateList find = NULL;
int ncandidates = 0;
HeapTuple ftup;
Form_pg_proc pp;
AclResult aclresult;
buf = palloc(strlen(value) + 1);
/* parse function name */
nextp = value;
do
{
if (*nextp == '\"')
{
/* Quoted name */
for (;;)
{
nextp = strchr(nextp + 1, '\"');
/* mismatched quotes */
if (nextp == NULL)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("function call syntax error: %s", value)));
if (nextp[1] != '\"')
break; /* found end of quoted name */
}
/* nextp now points at the terminating quote */
nextp = nextp + 1;
}
else if (IsIdentStart((unsigned char) *nextp))
{
/* Unquoted name */
nextp++;
while (IsIdentContent((unsigned char) *nextp))
nextp++;
}
else
{
/* invalid syntax */
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("function call syntax error: %s", value)));
}
while (isspace((unsigned char) *nextp))
nextp++; /* skip trailing whitespace */
if (*nextp == '.')
{
nextp++;
while (isspace((unsigned char) *nextp))
nextp++; /* skip leading whitespace for next */
/* we expect another name, so done remains false */
}
else if (*nextp == '\0' || *nextp == '(')
done = true;
else
{
/* invalid syntax */
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("function call syntax error: %s", value)));
}
/* Loop back if we didn't reach end of function name */
} while (!done);
strncpy(buf, value, nextp - value);
buf[nextp - value] = '\0';
names = stringToQualifiedNameList(buf);
pfree(buf);
if (*nextp == '\0')
{
if (!argistype)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("function call syntax error: %s", value)));
nargs = -1;
/* Get list of possible candidates from namespace search */
candidates = FuncnameGetCandidates(names, nargs, NIL, false, false);
}
else
{
/* parse function arguments */
nargs = 0;
while (GetNextArgument(nextp, &ret.args[nargs], &ret.argtypes[nargs], &nextp, value, argistype))
{
nargs++;
if (nargs > FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
errmsg("functions cannot have more than %d arguments", FUNC_MAX_ARGS)));
}
/* Get list of possible candidates from namespace search */
candidates = FuncnameGetCandidates(names, nargs, NIL, true, true);
}
/* so now try to match up candidates */
if (!argistype)
{
FuncCandidateList current_candidates;
ncandidates = func_match_argtypes(nargs,
ret.argtypes,
candidates,
¤t_candidates);
/* one match only? then run with it... */
if (ncandidates == 1)
find = current_candidates;
/* multiple candidates? then better decide or throw an error... */
else if (ncandidates > 1)
{
find = func_select_candidate(nargs, ret.argtypes,
current_candidates);
}
}
else if (nargs > 0)
{
/* Quickly check if there is an exact match to the input datatypes */
for (find = candidates; find; find = find->next)
{
if (memcmp(find->args, ret.argtypes, nargs * sizeof(Oid)) == 0)
{
ncandidates = 1;
break;
}
}
}
else
{
FuncCandidateList c;
for (c = candidates; c; c = c->next)
ncandidates++;
find = candidates;
}
if (ncandidates == 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
errmsg("function %s does not exist",
func_signature_string(names, nargs, NIL, ret.argtypes)),
errhint("No function matches the given name and argument types.")));
/*
* If we were able to choose a best candidate, we're done.
* Otherwise, ambiguous function call.
*/
if (ncandidates > 1 || !OidIsValid(find->oid))
ereport(ERROR,
(errcode(ERRCODE_AMBIGUOUS_FUNCTION),
errmsg("function %s is not unique",
func_signature_string(names, nargs, NIL,
ret.argtypes)),
errhint("Could not choose a best candidate function.")));
foreach (l, names)
{
Value *v = lfirst(l);
pfree(strVal(v));
pfree(v);
}
globle void AdditionFunction(
void *theEnv,
DATA_OBJECT_PTR returnValue)
{
double ftotal = 0.0;
double ftmp = 0.0;
long long ltotal = 0LL;
long long ltmp = 0LL;
intBool useFloatTotal = FALSE;
EXPRESSION *theExpression;
DATA_OBJECT theArgument;
int pos = 1;
/*=================================================*/
/* Loop through each of the arguments adding it to */
/* a running total. If a floating point number is */
/* encountered, then do all subsequent operations */
/* using floating point values. */
/*=================================================*/
theExpression = GetFirstArgument();
while (theExpression != NULL) {
if (! GetNumericArgument(theEnv,theExpression,"+",&theArgument,useFloatTotal,pos))
theExpression = NULL;
else
theExpression = GetNextArgument(theExpression);
if (useFloatTotal) {
ftmp = ValueToDouble(theArgument.value);
if(ftmp != 0.0)
ftotal += ftmp;
} else {
if (theArgument.type == INTEGER) {
ltmp = ValueToLong(theArgument.value);
if(ltmp != 0LL)
ltotal += ltmp;
} else {
ftmp = ValueToDouble(theArgument.value);
if(ftmp == 0.0) {
ftotal = (double)ltotal;
} else {
ftotal = (double)ltotal + ftmp;
}
useFloatTotal = TRUE;
}
}
pos++;
}
/*======================================================*/
/* If a floating point number was in the argument list, */
/* then return a float, otherwise return an integer. */
/*======================================================*/
if (useFloatTotal) {
returnValue->type = FLOAT;
returnValue->value = (void *) EnvAddDouble(theEnv,ftotal);
} else {
returnValue->type = INTEGER;
returnValue->value = (void *) EnvAddLong(theEnv,ltotal);
}
}
globle intBool GreaterThanFunction(
void *theEnv,
EXEC_STATUS)
{
EXPRESSION *theArgument;
DATA_OBJECT rv1, rv2;
int pos = 1;
/*=========================*/
/* Get the first argument. */
/*=========================*/
theArgument = GetFirstArgument();
if (theArgument == NULL) { return(TRUE); }
if (! GetNumericArgument(theEnv,execStatus,theArgument,">",&rv1,FALSE,pos)) return(FALSE);
pos++;
/*==========================================*/
/* Compare each of the subsequent arguments */
/* to its predecessor. If any is lesser or */
/* equal, then return FALSE. */
/*==========================================*/
for (theArgument = GetNextArgument(theArgument);
theArgument != NULL;
theArgument = GetNextArgument(theArgument), pos++)
{
if (! GetNumericArgument(theEnv,execStatus,theArgument,">",&rv2,FALSE,pos)) return(FALSE);
if (rv1.type == INTEGER)
{
if (rv2.type == INTEGER)
{
if (ValueToLong(rv1.value) <= ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if ((double) ValueToLong(rv1.value) <= ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
else
{
if (rv2.type == INTEGER)
{
if (ValueToDouble(rv1.value) <= (double) ValueToLong(rv2.value))
{ return(FALSE); }
}
else
{
if (ValueToDouble(rv1.value) <= ValueToDouble(rv2.value))
{ return(FALSE); }
}
}
rv1.type = rv2.type;
rv1.value = rv2.value;
}
/*================================*/
/* Each argument was greater than */
/* its predecessor. Return TRUE. */
/*================================*/
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); }
}
}
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); }
}
}
/*
*******************************************************************
* Function: int CGBLBuildCommand::DoHandleNextNetworkArgument (const CKBehaviorContext& behaviorContext)
*
* Description : Checks if there are more arguments to be specified for network command
* and takes corresponded actions
*
* Parameters :
* behaviourContext r Behavior context reference, which gives
* access to frequently used global objects
* ( context, level, manager, etc... )
*
*******************************************************************
*/
int CGBLBuildCommand::DoHandleNextNetworkArgument (const CKBehaviorContext& behaviorContext)
{
CKBehavior* behavior = behaviorContext.Behavior;
CKContext* context = behaviorContext.Context;
int gblBuildCommandState;
CKBehavior* targetBB = NULL;
CK_ID targetID;
behavior->GetLocalParameterValue (targetBBLocalPos, &targetID);
targetBB = (CKBehavior*)behaviorContext.Context->GetObject(targetID);
if (targetBB == NULL)
{
CKParameterOut *parameterOutError = behavior->GetOutputParameter(EGBLBuildCommandParamOutputs::GetError);
TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLFC_ERROR_BUILDCOMMAND_TARGET_NOT_FOUND,GBLFC_ERROR_BUILDCOMMAND_TARGET_NOT_FOUND_DESC);
behavior->ActivateOutput (EGBLBuildCommandBehOutputs::Error);
return CKBR_OK;
}
int currentParameterPosition = 0;
behavior->GetLocalParameterValue (currentParameterPositionLocalPos, ¤tParameterPosition);
CKParameter* nextArgument = CGBLCommandUtil::GetCommandArgument(*targetBB, currentParameterPosition);
currentParameterPosition++;
behavior->SetLocalParameterValue (currentParameterPositionLocalPos, ¤tParameterPosition);
if (nextArgument == NULL)
{
//no arguments required, build finished
CKParameter *outputCommandString, *localCommandString;
CKParameter *outputDests;
CKParameterIn *inputDests;
ClearParameterOutputs(behaviorContext);
outputCommandString = (CKParameter*) behavior->GetOutputParameter (EGBLBuildCommandParamOutputs::GetCommandString);
localCommandString = (CKParameter*) behavior->GetLocalParameter (commandStringLocalPos);
outputCommandString->CopyValue(localCommandString);
// Copy list of recipients from input to output
outputDests = (CKParameter*) (behavior->GetOutputParameter (EGBLBuildCommandParamOutputs::GetDests));
inputDests = behavior->GetInputParameter (EGBLBuildCommandParamInputs::SetDests);
outputDests->CopyValue(inputDests->GetDirectSource());
gblBuildCommandState = EGBLBuildCommandState::Completed;
behavior->SetLocalParameterValue (gblBuildCommandStateLocalPos, &gblBuildCommandState);
behavior->ActivateOutput (EGBLBuildCommandBehOutputs::HandleTargetedCommand);
return CKBR_OK;
}
else
{
//get next argument
gblBuildCommandState = EGBLBuildCommandState::AwaitingParametersForNetwork;
behavior->SetLocalParameterValue (gblBuildCommandStateLocalPos, &gblBuildCommandState);
GetNextArgument (nextArgument, targetBB, behaviorContext);
return CKBR_OK;
}
}
