void iVjr_init_createConstants(void)
{
s32 lnValue;
f32 lfValue;
// System constants used internally
cvarSpace1 = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, cgc_spaceText, 1, false);
cvarEmptyString = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, (cu8*)NULL, 0, false);
cvarSpace2000 = iVariable_create(NULL, _VAR_TYPE_CHARACTER, NULL, true);
cvarTrue = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_LOGICAL, (cu8*)NULL, 0, false);
cvarFalse = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_LOGICAL, (cu8*)NULL, 0, false);
cvarZero = iVariable_create(NULL, _VAR_TYPE_S64, NULL, true);
lnValue = 6;
cvarSix = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lnValue = 8;
cvarEight = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lnValue = 16;
cvarSixteen = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lnValue = 32;
cvarThirtyTwo = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lnValue = 64;
cvarSixtyFour = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lnValue = 255;
cvarTwoFiftyFive = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_S32, (cu8*)&lnValue, 4, false);
lfValue = 0.5f;
cvarFiftyPercent = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_F32, (cu8*)&lfValue, 4, false);
lfValue = 0.5f;
cvarOneHundredPercent = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_F32, (cu8*)&lfValue, 4, false);
// 2000 blank spaces
iDatum_allocateSpace(&cvarSpace2000->value, 2000);
memset(cvarSpace2000->value.data, 32, 2000);
// Constant logical
*cvarTrue->value.data_s8 = (s8)_LOGICAL_TRUE;
*cvarFalse->value.data_s8 = (s8)_LOGICAL_FALSE;
// Datetime constants for parsing
cvarSetDateAmerican = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "11/22/3333 12:34:56.000 AP", -1, true);
cvarSetDateAnsi = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "3333.22.11 12:34:56.000 AP", -1, true);
cvarSetDateBritish = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "22/11/3333 12:34:56.000 AP", -1, true);
cvarSetDateFrench = cvarSetDateBritish;
cvarSetDateGerman = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "22.11.3333 12:34:56.000 AP", -1, true);
cvarSetDateItalian = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "22-11-3333 12:34:56.000 AP", -1, true);
cvarSetDateJapan = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "3333/11/22 12:34:56.000 AP", -1, true);
cvarSetDateTaiwan = cvarSetDateJapan;
cvarSetDateLong = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "Dow, Mon 22, 3333 12:34:56.000 AP", -1, true);
cvarSetDateShort = cvarSetDateAmerican;
cvarSetDateUsa = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "11-22-33333 12:34:56.000 AP", -1, true);
cvarSetDateDmy = cvarSetDateBritish;
cvarSetDateMdy = cvarSetDateAmerican;
cvarSetDateYmd = cvarSetDateJapan;
// Other datetime constants for fixed date types
varSetDateYyyyMmDdTHhMmSsMss = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "3333-11-22 12:34:56.000 AP", -1, true);
varSetDateYyyyMmDdTHhMmSs = iVariable_createAndPopulate_byText(NULL, _VAR_TYPE_CHARACTER, "3333-11-22 12:34:56 AP", -1, true);
}
//////////
//
// Function: INT()
// Takes a value and returns the INT(n) of that value.
//
//////
// Version 0.58
// Last update:
// Apr.02.2015
//////
// Change log:
// Apr.02.2015 - Refactoring
// Jul.13.2014 - Initial creation
//////
// Parameters:
// p1 -- Numeric or floating point
//
//////
// Returns:
// INT(n) of the value in p1
//////
void function_int(SReturnsParams* rpar)
{
SVariable* varNumber = rpar->ip[0];
f64 fValue;
u32 errorNum;
bool error;
SVariable* result;
//////////
// Parameter 1 must be numeric
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varNumber) || !iVariable_isTypeNumeric(varNumber))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber), false);
return;
}
//////////
// Based on its type, process it accordingly
//////
if (iVariable_isTypeFloatingPoint(varNumber))
{
fValue = iiVariable_getAs_f64(varNumber, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber), false);
return;
}
// Convert to S64
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
if (result)
*(s64*)result->value.data_s8 = (s64)fValue;
} else {
// Copy whatever it already is
result = iVariable_copy(varNumber, false);
}
//////////
// Are we good?
//////
if (!result)
{
iError_report(cgcInternalError, false);
return;
}
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
//////////
//
// Function: LOWER()
// Converts every character in the string to lowercase.
//
//////
// Version 0.57
// Last update:
// Jul.12.2014
//////
// Change log:
// Jul.12.2014 - Initial creation
//////
// Parameters:
// pString -- Character, the string to lower
//
//////
// Returns:
// Character -- The string with all lowercase characters converted to lowercase
//////
void function_lower(SThisCode* thisCode, SFunctionParms* rpar)
{
SVariable* varString = rpar->params[0];
s32 lnI;
SVariable* result;
//////////
// Parameter 1 must be character
//////
rpar->returns[0] = NULL;
if (!iVariable_isValid(varString) || iVariable_getType(varString) != _VAR_TYPE_CHARACTER)
{
iError_reportByNumber(thisCode, _ERROR_P1_IS_INCORRECT, iVariable_getRelatedComp(thisCode, varString), false);
return;
}
//////////
// Create our return result
//////
result = iVariable_create(thisCode, _VAR_TYPE_CHARACTER, NULL, true);
if (!result)
{
iError_report(thisCode, cgcInternalError, false);
return;
}
//////////
// Copy the source string
//////
iDatum_duplicate(&result->value, &varString->value);
//////////
// Lower every character
//////
for (lnI = 0; lnI < result->value.length; lnI++)
{
if (result->value.data[lnI] >= 'A' && result->value.data[lnI] <= 'Z')
result->value.data[lnI] += 0x20;
}
//////////
// Return our converted result
//////
rpar->returns[0] = result;
}
void iiVjr_init_createGlobalSystemVariable(SVariable** var, s32 tnType, cu8* tcName, cs8* tcInitValue, u32 tnInitValueLength)
{
// Create it
if (!tcInitValue) *var = iVariable_create(NULL, tnType, NULL, true);
else *var = iVariable_createAndPopulate_byText(NULL, tnType, tcInitValue, tnInitValueLength, false);
// Name it
iDatum_duplicate(&(*var)->name, tcName, -1);
// Mark it as a system variable
(*var)->isSysVar = true;
// Append it to global variables
iLl_appendExistingNodeAtEnd((SLL**)&varGlobals, (SLL*)*var);
}
//////////
//
// Function: LEN()
// Returns the length of the string.
//
//////
// Version 0.57
// Last update:
// Jul.12.2014
//////
// Change log:
// Jul.12.2014 - Initial creation
//////
// Parameters:
// pString -- Character, the string to return the length from
//
//////
// Returns:
// Numeric -- The length of the string
//////
void function_len(SThisCode* thisCode, SFunctionParms* rpar)
{
SVariable* varString = rpar->params[0];
SVariable* result;
//////////
// Parameter 1 must be character
//////
rpar->returns[0] = NULL;
if (!iVariable_isValid(varString) || iVariable_getType(varString) != _VAR_TYPE_CHARACTER)
{
iError_reportByNumber(thisCode, _ERROR_P1_IS_INCORRECT, iVariable_getRelatedComp(thisCode, varString), false);
return;
}
//////////
// Create our return result
//////
result = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!result)
{
iError_report(thisCode, cgcInternalError, false);
return;
}
//////////
// Populate based on the length
//////
*(s32*)result->value.data = varString->value.length;
//////////
// Return our converted result
//////
rpar->returns[0] = result;
}
//////////
//
// Function: VERSION()
// Based on input, retrieves various version information.
//
//////
// Version 0.58
// Last update:
// Jul.13.2014
//////
// Change log:
// Jul.13.2014 - Initial creation
//////
// Parameters:
// pIndex -- (Optional) If present, Numeric, in the range 1..5
//
//////
// Returns:
// Numeric or Character -- Depending on index, various values are returned
//////
void function_version(SReturnsParams* rpar)
{
SVariable* varIndex = rpar->ip[0];
s32 index;
u32 errorNum;
bool error;
u8* lptr;
SVariable* result;
//////////
// Parameter 1 must be numeric
//////
rpar->rp[0] = NULL;
lptr = NULL;
if (!iVariable_isValid(varIndex))
{
// They are requesting the default information
lptr = (u8*)cgcVersionText;
} else if (!iVariable_isTypeNumeric(varIndex)) {
// The parameter is not numeric
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varIndex), false);
return;
} else {
// It must be in the range 1..5
index = iiVariable_getAs_s32(varIndex, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varIndex), false);
return;
} else if (index < 1 || index > 5) {
// We report our own error
iError_report((cu8*)"Parameter must be in the range 1..5", false);
return;
}
}
//////////
// Create our return result
//////
if (lptr || index == 1 || index == 4)
{
// Character return
result = iVariable_create(_VAR_TYPE_CHARACTER, NULL, true);
if (lptr)
{
// Copy the version info
iDatum_duplicate(&result->value, lptr, -1);
} else if (index == 1) {
// Copy the version1 info
iDatum_duplicate(&result->value, cgcVersion1Text, -1);
} else {
// Copy the version4 info
iDatum_duplicate(&result->value, cgcVersion4Text, -1);
}
} else {
result = iVariable_create(_VAR_TYPE_S32, NULL, true);
if (index == 2)
{
// 0=runtime, 1=standard, 2=professional
*(s32*)result->value.data = gnVersion2; // Oh yeah!
} else if (index == 3) {
// Localized version
*(s32*)result->value.data = gnVersion3; // English
} else {
// Version in a form like Major.Minor as M.mm, or 123 for version 1.23
*(s32*)result->value.data = gnVersion5;
}
}
if (!result)
{
iError_report(cgcInternalError, false);
return;
}
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
//////////
//
// Function: VAL()
// Returns a numeric or currency value from a expression.
//
//////
// Version 0.58
// Last update:
// Mar.22.2015
//////
// Change log:
// Mar.21.2015 - Initial creation by Stefano D'Amico
//////
// Parameters:
// varExpr -- Any, to convert
// varIgnoreList -- Characters to ignore
//
//////
// Returns:
// Numeric -- VAL( ) returns the numbers in the character expression from left to right until a non-numeric character is encountered.
// Leading blanks are ignored.
// VAL( ) returns 0 if the first character of the character expression is not a number, a dollar sign ($), a plus sign (+), or minus sign (-).
//////
void function_val(SReturnsParams* rpar)
{
SVariable* varExpr = rpar->ip[0];
SVariable* varIgnoreChars = rpar->ip[1];
s8 c, cCurrency, cPoint, cSeparator;
s32 lnI, lnJ, lnBuffOffset;
s64 lnValue;
f64 lfValue;
bool llAsInteger, llStillGoing, llCurrency;
SVariable* varCurrency;
SVariable* varPoint;
SVariable* varSeparator;
SVariable* result;
u32 errorNum;
bool error;
s8 buffer[64];
//////////
// Parameter 1 must be valid
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varExpr))
{
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varExpr), false);
return;
}
//////////
// If numeric, copy whatever's already there
//////
if (varExpr->varType >= _VAR_TYPE_NUMERIC_START && varExpr->varType <= _VAR_TYPE_NUMERIC_END)
{
// Copy The existing variable
result = iVariable_copy(varExpr, false);
if (!result)
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varExpr), false);
// Success or failure, return our result
rpar->rp[0] = result;
return;
}
//////////
// Determine what we're evaluating
//////
switch (varExpr->varType)
{
case _VAR_TYPE_NULL:
iError_report_byNumber(_ERROR_P1_IS_INCORRECT, iVariable_get_relatedComp(varExpr), false);
return;
break;
case _VAR_TYPE_LOGICAL: // 0=.F., 1=.T.
case _VAR_TYPE_DATE: // YYYYMMDD
result = iVariable_create(_VAR_TYPE_S32, NULL, true);
if (result)
{
// Populate the s32
*result->value.data_s32 = iiVariable_getAs_s32(varExpr, true, &error, &errorNum);
if (error)
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varExpr), false);
}
break;
case _VAR_TYPE_DATETIME:
// YYYYMMDDHhMmSsMss as s64
case _VAR_TYPE_DATETIMEX:
// YYYYMMDDHhMmSsNssssssss
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
if (result)
{
// Populate the s64
*result->value.data_s64 = iiVariable_getAs_s64(varExpr, true, &error, &errorNum);
if (error)
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varExpr), false);
}
break;
case _VAR_TYPE_CHARACTER:
//////////
// If present, parameter 2 must be valid
//////
if (varIgnoreChars)
{
if (!iVariable_isValid(varIgnoreChars) || !iVariable_isTypeCharacter(varIgnoreChars))
{
iError_report_byNumber(_ERROR_P2_IS_INCORRECT, iVariable_get_relatedComp(varIgnoreChars), false);
return;
}
}
//////////
// Prepare our characters
//////
varCurrency = propGet_settings_Currency(_settings);
varPoint = propGet_settings_Point(_settings);
varSeparator = propGet_settings_Separator(_settings);
if (!varCurrency || !varPoint || !varSeparator)
{
// Should never happen
iError_report_byNumber(_ERROR_INTERNAL_ERROR, NULL, false);
return;
}
//////////
// Create single characters
//////
cCurrency = varCurrency->value.data_s8[0];
cPoint = varPoint->value.data_s8[0];
cSeparator = varSeparator->value.data_s8[0];
//////////
// Iterate through each character
//////
for (lnI = 0, lnBuffOffset = 0, llStillGoing = true, llCurrency = false; llStillGoing && lnI < (s32)varExpr->value.length && lnBuffOffset < (s32)sizeof(buffer) - 1; lnI++)
{
//////////
// Grab this character
//////
c = varExpr->value.data[lnI];
//////////
// Is it a character we're including in our buffer (a number, or natural number-related symbol)?
//////
if ((c >= '0' && c <= '9' ) || c == '+' || c == '-' || c == cPoint)
{
// Yes, Copy this character
buffer[lnBuffOffset++] = c;
} else {
// Are we still in a valid sequence of characters to skip?
if (c == ' ' || c == cSeparator)
{
// It's a character we're skipping naturally (space, separator symbol)
// We don't do anything here ... it's just more clear to keep this logic visible rather than inverting it. :-)
} else if (c == cCurrency) {
// We encountered the currency symbol, so the output will be currency
llCurrency = true;
} else if (varIgnoreChars) {
// We won't continue unless we're sitting on a character in the varIgnoreChars
for (lnJ = 0, llStillGoing = false; lnJ < varIgnoreChars->value.length; lnJ++)
{
// Is this one of our skip characters?
if (c == varIgnoreChars->value.data_s8[lnJ])
{
llStillGoing = true;
break;
}
}
} else {
// We're done
break;
}
}
}
// NULL terminate
buffer[lnBuffOffset] = 0;
//////////
// Convert to f64, and s64
//////
lfValue = atof(buffer);
#if defined(__GNUC__) || defined(__solaris__)
lnValue = strtoll(buffer, NULL, 10);
#else
lnValue = _strtoi64(buffer, NULL, 10);
#endif
//////////
// Is currency or not? If it's an integer value, store it as the same, otherwise use floating point
//////
if ((f64)lnValue == lfValue)
{
// We can return as an integer
llAsInteger = true;
if (llCurrency)
{
// Multiply by 10000 to obtain the 4 implied decimal places
lnValue = lnValue * 10000;
result = iVariable_create(_VAR_TYPE_CURRENCY, NULL, true);
} else {
if (lnValue < (s64)_s32_max)
{
// We can create as an s32
result = iVariable_create(_VAR_TYPE_S32, NULL, true);
} else {
// Create as an s64
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
}
}
} else {
// Must return as f64
llAsInteger = false;
if (llCurrency)
{
// As currency
lfValue *= 10000.0;
result = iVariable_create(_VAR_TYPE_CURRENCY, NULL, true);
} else {
// As is
result = iVariable_create(_VAR_TYPE_F64, NULL, true);
}
}
//////////
// Store the result
//////
if (result)
{
if (llAsInteger) iVariable_setNumeric_toNumericType(result, NULL, NULL, NULL, NULL, &lnValue, NULL);
else iVariable_setNumeric_toNumericType(result, NULL, &lfValue, NULL, NULL, NULL, NULL);
}
break;
default:
// Unrecognized type
iError_report_byNumber(_ERROR_FEATURE_NOT_AVAILABLE, iVariable_get_relatedComp(varExpr), false);
return;
}
//////////
// Are we good?
//////
if (!result)
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varExpr), false);
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
// Common numeric functions used for EXP(), LOG(), LOG10(), PI(), SQRT(), CEILING(), FLOOR(), DTOR(), RTOD(), ...
void ifunction_numbers_common(SReturnsParams* rpar, SVariable* varNumber1, SVariable* varNumber2, SVariable* varNumber3, u32 tnFunctionType, const u32 tnResultType, bool tlSameInputType, bool tlNoEmptyParam)
{
f64 lfResult, lfValue1, lfValue2, lfValue3;
u32 errorNum;
bool error;
SVariable* result;
//////////
// If varNumber1 is provided, must also be numeric
//////
rpar->rp[0] = NULL;
if (varNumber1)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber1) || !iVariable_isTypeNumeric(varNumber1))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Convert to f64
//////
lfValue1 = iiVariable_getAs_f64(varNumber1, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue1 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber1), false);
return;
}
} else {
lfValue1 = 0.0;
}
//////////
// If varNumber2 is provided, must also be numeric
//////
if (varNumber2)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber2) || !iVariable_isTypeNumeric(varNumber2))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Convert to f64
//////
lfValue2 = iiVariable_getAs_f64(varNumber2, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue2 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber2), false);
return;
}
} else {
lfValue2 = 0.0;
}
//////////
// If varNumber3 is provided, must also be numeric
//////
if (varNumber3)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber3) || !iVariable_isTypeNumeric(varNumber3))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber3), false);
return;
}
//////////
// Convert to f64
//////
lfValue3 = iiVariable_getAs_f64(varNumber3, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber3), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue3 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber3), false);
return;
}
} else {
lfValue3 = 0.0;
}
//////////
// Compute numeric function
//////
switch (tnFunctionType)
{
// SQRT()
case _FP_COMMON_SQRT:
//////////
// Verify p1 >= 0
//////
if (lfValue1 < 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_CANNOT_BE_NEGATIVE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute sqrt
//////
lfResult = sqrt(lfValue1);
break;
// EXP()
case _FP_COMMON_EXP:
lfResult = exp(lfValue1);
break;
// PI()
case _FP_COMMON_PI:
lfResult = _MATH_PI;
break;
// LOG()
// LOG10()
case _FP_COMMON_LOG:
case _FP_COMMON_LOG10:
//////////
// Verify p1 > 0
//////
if (lfValue1 <= 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO_OR_NEGATIVE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
if (tnFunctionType == _FP_COMMON_LOG) lfResult = log(lfValue1);
else lfResult = log10(lfValue1);
break;
// CEILING()
case _FP_COMMON_CEILING:
lfResult = ceil(lfValue1);
break;
// FLOOR()
case _FP_COMMON_FLOOR:
lfResult = floor(lfValue1);
break;
// DTOR()
case _FP_COMMON_DTOR:
lfResult = lfValue1 * _MATH_PI180;
break;
// RTOD()
case _FP_COMMON_RTOD:
lfResult = lfValue1 * _MATH_180PI;
break;
// COS()
case _FP_COMMON_COS:
lfResult = cos(lfValue1);
break;
// SIN()
case _FP_COMMON_SIN:
lfResult = sin(lfValue1);
break;
// ABS()
case _FP_COMMON_ABS:
lfResult = abs(lfValue1);
break;
// ACOS()
// ASIN()
case _FP_COMMON_ACOS:
case _FP_COMMON_ASIN:
//////////
// Verify p1 > 0
//////
if (lfValue1 < -1 || lfValue1 > 1)
{
// Oops!
iError_report_byNumber(_ERROR_OUT_OF_RANGE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
if (tnFunctionType == _FP_COMMON_ACOS) lfResult = acos(lfValue1);
else lfResult = asin(lfValue1);
break;
// ATAN()
case _FP_COMMON_ATAN:
//////////
// Verify p1 > 0
//////
if (lfValue1 < -_MATH_PI2 || lfValue1 > _MATH_PI2)
{
// Oops!
iError_report_byNumber(_ERROR_OUT_OF_RANGE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
lfResult = atan(lfValue1);
break;
// ATN2()
case _FP_COMMON_ATN2:
lfResult = atan2(lfValue1, lfValue2);
break;
// TAN()
case _FP_COMMON_TAN:
lfResult = tan(lfValue1);
break;
// MOD()
case _FP_COMMON_MOD:
//////////
// Verify divisor not 0
//////
if (lfValue2 == 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_DIVISION_BY_ZERO, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Compute
//////
lfResult = fmod(lfValue1, abs(lfValue2));
if (lfValue2 < 0 && lfResult != 0.0) // Mar.14.2015
lfResult += lfValue2;
break;
// FV()
case _FP_COMMON_FV:
//////////
// Future value
//////
lfResult = (pow((1 + lfValue2), lfValue3) - 1) / lfValue2 * lfValue1;
break;
// PV()
case _FP_COMMON_PV:
//////////
// Present value
//////
lfResult = lfValue1 * ((1 - pow((1 + lfValue2), -lfValue3)) / lfValue2);
break;
// PAYMENT()
case _FP_COMMON_PAYMENT:
//////////
// Payment
//////
lfValue1 = (lfValue1 * pow(lfValue2 + 1, lfValue3) * lfValue2) / (pow(lfValue2 + 1, lfValue3) - 1);
break;
default:
// Programmer error... this is an internal function and we should never get here
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Create output variable
//////
if (tlSameInputType) result = iVariable_create(varNumber1->varType, NULL, true);
else result = iVariable_create(tnResultType, NULL, true);
if (!result)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Set the value
//////
if (!iVariable_setNumeric_toNumericType(result, NULL, &lfResult, NULL, NULL, NULL, NULL))
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
//////////
// return(result)
//////
rpar->rp[0] = result;
}
//////////
//
// Called to reset an object's events to its default
//
//////
void iEvents_resetToDefault(SThisCode* thisCode, SObject* obj)
{
// Make sure our environment is sane
if (obj)
{
//////////
// onMouseMove
//////
if (!obj->ev.varX_onMouseMove) obj->ev.varX_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varY_onMouseMove) obj->ev.varY_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varCtrl_onMouseMove) obj->ev.varCtrl_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onMouseMove) obj->ev.varAlt_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onMouseMove) obj->ev.varShift_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varClick_onMouseMove) obj->ev.varClick_onMouseMove = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
//////////
// onMouseDown
//////
if (!obj->ev.varX_onMouseDown) obj->ev.varX_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varY_onMouseDown) obj->ev.varY_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varCtrl_onMouseDown) obj->ev.varCtrl_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onMouseDown) obj->ev.varAlt_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onMouseDown) obj->ev.varShift_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varClick_onMouseDown) obj->ev.varClick_onMouseDown = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
//////////
// onMouseClickEx
//////
if (!obj->ev.varX_onMouseClickEx) obj->ev.varX_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varY_onMouseClickEx) obj->ev.varY_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varCtrl_onMouseClickEx) obj->ev.varCtrl_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onMouseClickEx) obj->ev.varAlt_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onMouseClickEx) obj->ev.varShift_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varClick_onMouseClickEx) obj->ev.varClick_onMouseClickEx = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
//////////
// onMouseUp
//////
if (!obj->ev.varX_onMouseUp) obj->ev.varX_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varY_onMouseUp) obj->ev.varY_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varCtrl_onMouseUp) obj->ev.varCtrl_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onMouseUp) obj->ev.varAlt_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onMouseUp) obj->ev.varShift_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varClick_onMouseUp) obj->ev.varClick_onMouseUp = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
//////////
// onMouseWheel
//////
if (!obj->ev.varX_onMouseWheel) obj->ev.varX_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varY_onMouseWheel) obj->ev.varY_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varCtrl_onMouseWheel) obj->ev.varCtrl_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onMouseWheel) obj->ev.varAlt_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onMouseWheel) obj->ev.varShift_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varClick_onMouseWheel) obj->ev.varClick_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
if (!obj->ev.varDeltaY_onMouseWheel) obj->ev.varDeltaY_onMouseWheel = iVariable_create(thisCode, _VAR_TYPE_S32, NULL, true);
//////////
// onKeyDown
//////
if (!obj->ev.varCtrl_onKeyDown) obj->ev.varCtrl_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onKeyDown) obj->ev.varAlt_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onKeyDown) obj->ev.varShift_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varCaps_onKeyDown) obj->ev.varCaps_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAsciiChar_onKeyDown) obj->ev.varAsciiChar_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_U16, NULL, true);
if (!obj->ev.varVKey_onKeyDown) obj->ev.varVKey_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_S16, NULL, true);
if (!obj->ev.varIsCAS_onKeyDown) obj->ev.varIsCAS_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varIsAscii_onKeyDown) obj->ev.varIsAscii_onKeyDown = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
//////////
// onKeyUp
//////
if (!obj->ev.varCtrl_onKeyUp) obj->ev.varCtrl_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAlt_onKeyUp) obj->ev.varAlt_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varShift_onKeyUp) obj->ev.varShift_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varCaps_onKeyUp) obj->ev.varCaps_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varAsciiChar_onKeyUp) obj->ev.varAsciiChar_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_U16, NULL, true);
if (!obj->ev.varVKey_onKeyUp) obj->ev.varVKey_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_S16, NULL, true);
if (!obj->ev.varIsCAS_onKeyUp) obj->ev.varIsCAS_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
if (!obj->ev.varIsAscii_onKeyUp) obj->ev.varIsAscii_onKeyUp = iVariable_create(thisCode, _VAR_TYPE_LOGICAL, NULL, true);
//////////
// Reset general events
//////
obj->ev.methods[_EVENT_RESIZE]._event = (uptr)&iDefaultCallback_resize;
obj->ev.methods[_EVENT_ONLOAD]._event = (uptr)&iDefaultCallback_onLoad;
obj->ev.methods[_EVENT_ONINIT]._event = (uptr)&iDefaultCallback_onInit;
obj->ev.methods[_EVENT_ONCREATED]._event = (uptr)&iDefaultCallback_onCreated;
obj->ev.methods[_EVENT_ONRESIZE]._event = (uptr)&iDefaultCallback_onResize;
obj->ev.methods[_EVENT_ONMOVED]._event = (uptr)&iDefaultCallback_onMoved;
obj->ev.methods[_EVENT_ONRENDER]._event = (uptr)&iDefaultCallback_onRender;
obj->ev.methods[_EVENT_ONPUBLISH]._event = (uptr)&iDefaultCallback_onPublish;
obj->ev.methods[_EVENT_ONQUERYUNLOAD]._event = (uptr)&iDefaultCallback_onQueryUnload;
obj->ev.methods[_EVENT_ONDESTROY]._event = (uptr)&iDefaultCallback_onDestroy;
obj->ev.methods[_EVENT_ONUNLOAD]._event = (uptr)&iDefaultCallback_onUnload;
obj->ev.methods[_EVENT_ONGOTFOCUS]._event = (uptr)&iDefaultCallback_onGotFocus;
obj->ev.methods[_EVENT_ONLOSTFOCUS]._event = (uptr)&iDefaultCallback_onLostFocus;
obj->ev.methods[_EVENT_ONADDOBJECT]._event = (uptr)&iDefaultCallback_onAddObject;
obj->ev.methods[_EVENT_ONADDPROPERTY]._event = (uptr)&iDefaultCallback_onAddProperty;
obj->ev.methods[_EVENT_ONERROR]._event = (uptr)&iDefaultCallback_onError;
obj->ev.methods[_EVENT_ONSCROLLED]._event = (uptr)&iDefaultCallback_onScrolled;
obj->ev.methods[_EVENT_ACTIVATE]._event = (uptr)&iDefaultCallback_onActivate;
obj->ev.methods[_EVENT_DEACTIVATE]._event = (uptr)&iDefaultCallback_onDeactivate;
obj->ev.methods[_EVENT_ONSELECT]._event = (uptr)&iDefaultCallback_onSelect;
obj->ev.methods[_EVENT_ONDESELECT]._event = (uptr)&iDefaultCallback_onDeselect;
obj->ev.methods[_EVENT_ONINTERACTIVECHANGE]._event = (uptr)&iDefaultCallback_onInteractiveChange;
obj->ev.methods[_EVENT_ONPROGRAMMATICCHANGE]._event = (uptr)&iDefaultCallback_onProgrammaticChange;
obj->ev.methods[_EVENT_ONSETACTIVECONTROL]._event = (uptr)&iDefaultCallback_onSetActiveControl;
obj->ev.methods[_EVENT_ONSPIN]._event = (uptr)&iDefaultCallback_onSpin;
obj->ev.methods[_EVENT_ONMOUSECLICKEX]._event = (uptr)&iDefaultCallback_onMouseClickEx;
obj->ev.methods[_EVENT_ONMOUSEDBLCLICKEX]._event = (uptr)&iDefaultCallback_onMouseDblClickEx;
obj->ev.methods[_EVENT_ONMOUSEWHEEL]._event = (uptr)&iDefaultCallback_onMouseWheel;
obj->ev.methods[_EVENT_ONMOUSEMOVE]._event = (uptr)&iDefaultCallback_onMouseMove;
obj->ev.methods[_EVENT_ONMOUSEDOWN]._event = (uptr)&iDefaultCallback_onMouseDown;
obj->ev.methods[_EVENT_ONMOUSEUP]._event = (uptr)&iDefaultCallback_onMouseUp;
obj->ev.methods[_EVENT_ONMOUSEENTER]._event = (uptr)&iDefaultCallback_onMouseEnter;
obj->ev.methods[_EVENT_ONMOUSELEAVE]._event = (uptr)&iDefaultCallback_onMouseLeave;
obj->ev.methods[_EVENT_ONMOUSEHOVER]._event = (uptr)&iDefaultCallback_onMouseHover;
obj->ev.methods[_EVENT_ONKEYDOWN]._event = (uptr)&iDefaultCallback_onKeyDown;
obj->ev.methods[_EVENT_ONKEYUP]._event = (uptr)&iDefaultCallback_onKeyUp;
obj->ev.methods[_EVENT_CAROUSEL_ONTABCLOSE]._event = (uptr)&iDefaultCallback_onTabClose;
obj->ev.methods[_EVENT_CAROUSEL_ONTABCLICK]._event = (uptr)&iDefaultCallback_onTabClick;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSEWHEEL]._event = (uptr)&iDefaultCallback_onTabMouseWheel;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSEMOVE]._event = (uptr)&iDefaultCallback_onTabMouseMove;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSEDOWN]._event = (uptr)&iDefaultCallback_onTabMouseDown;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSEUP]._event = (uptr)&iDefaultCallback_onTabMouseUp;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSEENTER]._event = (uptr)&iDefaultCallback_onTabMouseEnter;
obj->ev.methods[_EVENT_CAROUSEL_ONTABMOUSELEAVE]._event = (uptr)&iDefaultCallback_onTabMouseLeave;
}
}
//////////
//
// Function: LEFT()
// Returns the left N characters of a string.
//
//////
// Version 0.57
// Last update:
// Jul.12.2014
//////
// Change log:
// Jul.12.2014 - Initial creation
//////
// Parameters:
// pString -- Character, the string to trim
// pCount -- Numeric, the number of characters to copy
//
//////
// Returns:
// Character -- The string of the left N characters
//////
void function_left(SThisCode* thisCode, SFunctionParms* rpar)
{
SVariable* varString = rpar->params[0];
SVariable* varCount = rpar->params[1];
s32 lnLength;
u32 errorNum;
bool error;
SVariable* result;
//////////
// Parameter 1 must be character
//////
rpar->returns[0] = NULL;
if (!iVariable_isValid(varString) || iVariable_getType(varString) != _VAR_TYPE_CHARACTER)
{
iError_reportByNumber(thisCode, _ERROR_P1_IS_INCORRECT, iVariable_getRelatedComp(thisCode, varString), false);
return;
}
//////////
// Parameter 2 must be numeric
//////
if (!iVariable_isValid(varCount) || !iVariable_isTypeNumeric(varCount))
{
iError_reportByNumber(thisCode, _ERROR_P2_IS_INCORRECT, iVariable_getRelatedComp(thisCode, varCount), false);
return;
}
//////////
// Find out how long they want our string to be
//////
lnLength = iiVariable_getAs_s32(thisCode, varCount, false, &error, &errorNum);
if (error)
{
iError_reportByNumber(thisCode, errorNum, iVariable_getRelatedComp(thisCode, varCount), false);
return;
}
//////////
// Create our return result
//////
result = iVariable_create(thisCode, _VAR_TYPE_CHARACTER, NULL, true);
if (!result)
{
iError_report(thisCode, cgcInternalError, false);
return;
}
//////////
// Copy as much of the source string as will fit
//////
if (lnLength > 0)
iDatum_duplicate(&result->value, varString->value.data_u8, min(varString->value.length, lnLength));
//////////
// Return our converted result
//////
rpar->returns[0] = result;
}
