bool iiDefaultCallback_processMouseVariables( SVariable* varX, SVariable* varY, SVariable* varCtrl, SVariable* varAlt, SVariable* varShift, SVariable* varClick,
s32* lnX, s32* lnY, bool* tlCtrl, bool* tlAlt, bool* tlShift, u32* lnClick)
{
//////////
// Validate the variables are appropriate
//////
if (!iVariable_isValid(varX) || !iVariable_isValid(varY) || !iVariable_isValid(varCtrl) || !iVariable_isValid(varAlt) || !iVariable_isValid(varShift) || !iVariable_isValid(varClick))
{
// Something is invalid, ignore it
return(false);
}
if (!iVariable_isTypeNumeric(varX) || !iVariable_isTypeNumeric(varY) || !iVariable_isTypeLogical(varCtrl) || !iVariable_isTypeLogical(varAlt) || !iVariable_isTypeLogical(varShift) || !iVariable_isTypeNumeric(varClick))
{
// Something is not a proper variable, ignore it
return(false);
}
*lnX = (s16)iiVariable_getAs_s32(varX, false, NULL, NULL);
*lnY = (u16)iiVariable_getAs_s32(varY, false, NULL, NULL);
*tlCtrl = iiVariable_getAs_bool(varCtrl, false, NULL, NULL);
*tlAlt = iiVariable_getAs_bool(varAlt, false, NULL, NULL);
*tlShift = iiVariable_getAs_bool(varShift, false, NULL, NULL);
*lnClick = iiVariable_getAs_u32(varClick, false, NULL, NULL);
//////////
// Indicate we successfully parsed the variables
//////
return(true);
}
//////////
//
// Function: VARTYPE()
// Returns the variable type, parsing NULL values.
//
//////
// Version 0.58
// Last update:
// Apr.06.2015
//////
// Change log:
// Apr.06.2015 - Initial creation
//////
// Parameters:
// P1 -- The variable to examine
// P2 -- (Optional) If provided, .t. or .f. indicating if NULL values should return the type (default to .f.)
//
//////
// Returns:
// Character -- A one-digit value indicating the type
//////
void function_vartype(SReturnsParams* rpar)
{
SVariable* var = rpar->ip[0];
SVariable* varNull = rpar->ip[1];
bool llNullIsType;
bool error;
u32 errorNum;
//////////
// varLookup must exist
//////
rpar->rp[0] = NULL;
if (!iVariable_isValidType(var))
{
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(var), false);
return;
}
//////////
// If varNull is specified, must be logical
//////
if (varNull)
{
//////////
// Must be logical
//////
if (!iVariable_isValid(varNull) || !iVariable_isTypeLogical(varNull))
{
iError_report_byNumber(_ERROR_P2_IS_INCORRECT, iVariable_get_relatedComp(varNull), false);
return;
}
//////////
// Grab the value
//////
llNullIsType = iiVariable_getAs_bool(varNull, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNull), false);
return;
}
} else {
// Do not report on NULL types
llNullIsType = false;
}
//////////
// Compute our result
//////
ifunction_type_common(rpar, var, false, true, llNullIsType);
}
//////////
//
// Function: IIF()
// Immediate if.
//
//////
// Version 0.58
// Last update:
// Mar.22.2015
//////
// Change log:
// Mar.22.2015 - Initial creation
//////
// Parameters:
// varTest -- The logical test result
// varTrue -- The value to use if true
// varFalse -- The value to use if false
//
//////
// Returns:
// A copy of either varTrue or varFalse.
//////
void function_iif(SReturnsParams* rpar)
{
SVariable* varTest = rpar->ip[0];
SVariable* varTrue = rpar->ip[1];
SVariable* varFalse = rpar->ip[2];
bool llTest;
SVariable* result;
u32 errorNum;
bool error;
//////////
// Parameter 1 must be logical
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varTest) || !iVariable_isFundamentalTypeLogical(varTest))
{
iError_report_byNumber(_ERROR_MUST_BE_LOGICAL, iVariable_get_relatedComp(varTest), false);
return;
}
//////////
// Grab the test result
//////
llTest = iiVariable_getAs_bool(varTest, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varTest), false);
return;
}
//////////
// Based on the test, copy either varTrue or varFalse
//////
if (llTest)
{
// Copy true
result = iVariable_copy(varTrue, false);
} else {
// Copy false
result = iVariable_copy(varFalse, false);
}
//////////
// Are we good?
//////
if (!result)
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(((llTest) ? varTrue : varFalse)), false);
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
//////////
//
// Function: ISUPPER()
// Determines whether the first character in a character expression is an uppercase alphabetic character.
//
//////
// Version 0.58
// Last update:
// Sep.15.2015
//////
// Change log:
// Sep.15.2015 - Initial creation by Stefano D'Amico
//////
// Parameters:
// p1 -- Specifies the character expression that ISUPPER( ) evaluates.
// p2 -- Optional, if true evaluates all string
//
//////
// Returns:
// ISUPPER( ) returns true (.T.) if the first character in a character expression is an uppercase alphabetic character;
// otherwise, ISUPPER( ) returns false (.F.).
//////
// Example:
// ? ISUPPER("Aa") && Display .T.
// ? ISUPPER("Aa") && Display .T.
// ? ISUPPER("Aa", .T.) && Display .F.
// ? ISUPPER("AA", .T.) && Display .T.
//////
void function_isupper(SReturnsParams* rpar)
{
SVariable* varStr = rpar->ip[0];
SVariable* varTestWholeString = rpar->ip[1];
bool llTestWholeString, llIsUpper;
bool error;
u32 errorNum;
//////////
// Parameters 1 must be present and character
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varStr) || !iVariable_isTypeCharacter(varStr))
{
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varStr), false);
return;
}
//////////
// If present, parameter 2 must be bool
//////
if (varTestWholeString)
{
if (!iVariable_isFundamentalTypeLogical(varTestWholeString))
{
iError_report_byNumber(_ERROR_P2_IS_INCORRECT, iVariable_get_relatedComp(varTestWholeString), false);
return;
}
// Grab the value
llTestWholeString = iiVariable_getAs_bool(varTestWholeString, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varTestWholeString), false);
return;
}
} else {
// Just testing the first character
llTestWholeString = false;
}
//////////
// Create and populate the return variable
//////
llIsUpper = ifunction_iscommon(varStr, llTestWholeString, _isUpper);
rpar->rp[0] = iVariable_createAndPopulate_byText(_VAR_TYPE_LOGICAL, iVariable_populate_byBool(llIsUpper), 1, true);
if (!rpar->rp[0])
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varStr), false);
}
bool iiDefaultCallback_processKeyVariables( SVariable* varCtrl, SVariable* varAlt, SVariable* varShift, SVariable* varCaps, SVariable* varAscii, SVariable* varVKey, SVariable* varIsCAS, SVariable* varIsAscii,
bool* tlCtrl, bool* tlAlt, bool* tlShift, bool* tlCaps, bool* tlIsCAS, bool* tlIsAscii,
s16* lcAscii, u16* lnVKey)
{
//////////
// Validate the variables are appropriate
//////
if (!iVariable_isValid(varCtrl) || !iVariable_isValid(varAlt) || !iVariable_isValid(varShift) || !iVariable_isValid(varCaps) || !iVariable_isValid(varIsAscii) || !iVariable_isValid(varAscii) || !iVariable_isValid(varVKey))
{
// Something is invalid
return(false); // Do not continue consuming
}
if (!iVariable_isTypeLogical(varCtrl) || !iVariable_isTypeLogical(varAlt) || !iVariable_isTypeLogical(varShift) || !iVariable_isTypeLogical(varCaps) || !iVariable_isTypeLogical(varIsAscii) || !iVariable_isTypeNumeric(varAscii) || !iVariable_isTypeNumeric(varVKey))
{
// Something is not a proper variable
return(false); // Do not continue consuming
}
*tlCtrl = iiVariable_getAs_bool(varCtrl, false, NULL, NULL);
*tlAlt = iiVariable_getAs_bool(varAlt, false, NULL, NULL);
*tlShift = iiVariable_getAs_bool(varShift, false, NULL, NULL);
*tlCaps = iiVariable_getAs_bool(varCaps, false, NULL, NULL);
*tlIsCAS = iiVariable_getAs_bool(varIsCAS, false, NULL, NULL);
*tlIsAscii = iiVariable_getAs_bool(varIsAscii, false, NULL, NULL);
*lcAscii = iiVariable_getAs_s16(varAscii, false, NULL, NULL);
*lnVKey = iiVariable_getAs_u16(varVKey, false, NULL, NULL);
//////////
// Indicate we successfully parsed the keyboard variables
//////
return(true);
}
