/*
** Copyright (C) 2001-2025 Zabbix SIA
**
** This program is free software: you can redistribute it and/or modify it under the terms of
** the GNU Affero General Public License as published by the Free Software Foundation, version 3.
**
** This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
** without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
** See the GNU Affero General Public License for more details.
**
** You should have received a copy of the GNU Affero General Public License along with this program.
** If not, see <https://www.gnu.org/licenses/>.
**/
#include "zbxexpression.h"
#include "zbxnum.h"
#include "zbxvariant.h"
#include "zbxexpr.h"
#include "zbxalgo.h"
/******************************************************************************
* *
* Module for evaluating expressions *
* --------------------------------------- *
* *
* Global variables are used for efficiency reasons so that arguments do not *
* have to be passed to each of evaluate_termX() functions. For this reason, *
* too, this module is isolated into a separate file. *
* *
* The priority of supported operators is as follows: *
* *
* - (unary) evaluate_term8() *
* not evaluate_term7() *
* * / evaluate_term6() *
* + - evaluate_term5() *
* < <= >= > evaluate_term4() *
* = <> evaluate_term3() *
* and evaluate_term2() *
* or evaluate_term1() *
* *
* Function evaluate_term9() is used for parsing tokens on the lowest level: *
* those can be suffixed numbers like "12.345K" or parenthesized expressions. *
* *
******************************************************************************/
static const char *ptr; /* character being looked at */
static int level; /* expression nesting level */
static char *buffer; /* error message buffer */
static size_t max_buffer_len; /* error message buffer size */
/******************************************************************************
* *
* Purpose: check whether the character delimits a numeric token. *
* *
******************************************************************************/
static int is_number_delimiter(char c)
{
return 0 == isdigit(c) && '.' != c && 0 == isalpha(c) ? SUCCEED : FAIL;
}
/******************************************************************************
* *
* Purpose: check whether the character delimits a symbolic operator token. *
* *
******************************************************************************/
static int is_operator_delimiter(char c)
{
return ' ' == c || '(' == c || '\r' == c || '\n' == c || '\t' == c || ')' == c || '\0' == c ? SUCCEED : FAIL;
}
/******************************************************************************
* *
* Purpose: evaluate a quoted string like "/etc/passwd". Characters '\' and *
* '"' are expected to be escaped or parsing fails *
* *
******************************************************************************/
static void evaluate_string(zbx_variant_t *res)
{
const char *start;
char *res_temp = NULL, *dst;
int str_len = 0;
for (start = ptr; '"' != *ptr; ptr++)
{
if ('\\' == *ptr)
{
ptr++;
if ('\\' != *ptr && '\"' != *ptr && '\0' != *ptr)
{
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" invalid escape sequence at \"%s\".", ptr - 1);
zbx_variant_set_dbl(res, ZBX_INFINITY);
return;
}
}
if ('\0' == *ptr)
{
zbx_variant_set_dbl(res, ZBX_INFINITY);
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" unterminated string at \"%s\".", start);
return;
}
}
str_len = ptr - start;
res_temp = zbx_malloc(NULL, str_len + 1);
for (dst = res_temp; start != ptr; start++)
{
switch (*start)
{
case '\\':
start++;
break;
case '\r':
continue;
}
*dst++ = *start;
}
*dst = '\0';
zbx_variant_set_str(res, res_temp);
}
/******************************************************************************
* *
* Purpose: evaluate a suffixed number like 12.345K. *
* *
******************************************************************************/
static double evaluate_number(int *unknown_idx)
{
double result;
int len;
/* Is it a special token of unknown value (e.g. ZBX_UNKNOWN0, ZBX_UNKNOWN1) ? */
if (0 == strncmp(ZBX_UNKNOWN_STR, ptr, ZBX_UNKNOWN_STR_LEN))
{
const char *p0, *p1;
p0 = ptr + ZBX_UNKNOWN_STR_LEN;
p1 = p0;
/* extract the message number which follows after 'ZBX_UNKNOWN' */
while (0 != isdigit((unsigned char)*p1))
p1++;
if (p0 < p1 && SUCCEED == is_number_delimiter(*p1))
{
ptr = p1;
/* return 'unknown' and corresponding message number about its origin */
*unknown_idx = atoi(p0);
return ZBX_UNKNOWN;
}
ptr = p0;
return ZBX_INFINITY;
}
if (SUCCEED == zbx_suffixed_number_parse(ptr, &len) && SUCCEED == is_number_delimiter(*(ptr + len)))
{
result = atof(ptr) * suffix2factor(*(ptr + len - 1));
ptr += len;
}
else
result = ZBX_INFINITY;
return result;
}
/******************************************************************************
* *
* Purpose: cast string variant to a double variant. *
* *
* Parameters: var - [IN/OUT] the variant to cast *
* *
******************************************************************************/
static void variant_convert_to_double(zbx_variant_t *var)
{
if (ZBX_VARIANT_STR == var->type)
{
double var_double_value = zbx_evaluate_string_to_double(var->data.str);
if (ZBX_INFINITY == var_double_value)
{
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" value \"%s\" is not a numeric operand.", var->data.str);
}
zbx_variant_clear(var);
zbx_variant_set_dbl(var, var_double_value);
}
}
/******************************************************************************
* *
* Purpose: get variant value in double (float64) format. *
* *
* Parameters: var - [IN] the input variant *
* *
* Return value: depending on variant type: *
* DBL - the variant value *
* STR - if variant value contains valid float64 string (with supported *
* Zabbix suffixes) the converted value is returned. Otherwise *
* ZBX_INFINITY is returned. *
* other types - ZBX_INFINITY *
* *
******************************************************************************/
static double variant_get_double(const zbx_variant_t *var)
{
switch (var->type)
{
case ZBX_VARIANT_DBL:
return var->data.dbl;
case ZBX_VARIANT_STR:
return zbx_evaluate_string_to_double(var->data.str);
default:
THIS_SHOULD_NEVER_HAPPEN;
return ZBX_INFINITY;
}
}
static zbx_variant_t evaluate_term1(int *unknown_idx);
/******************************************************************************
* *
* Purpose: evaluate a suffixed number or a parenthesized expression. *
* *
******************************************************************************/
static zbx_variant_t evaluate_term9(int *unknown_idx)
{
zbx_variant_t res;
while (' ' == *ptr || '\r' == *ptr || '\n' == *ptr || '\t' == *ptr)
ptr++;
if ('\0' == *ptr)
{
zbx_strlcpy(buffer, "Cannot evaluate expression: unexpected end of expression.", max_buffer_len);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
return res;
}
if ('(' == *ptr)
{
ptr++;
res = evaluate_term1(unknown_idx);
if (ZBX_VARIANT_DBL == res.type && ZBX_INFINITY == res.data.dbl)
return res;
/* if evaluate_term1() returns ZBX_UNKNOWN then continue as with regular number */
if (')' != *ptr)
{
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" expected closing parenthesis at \"%s\".", ptr);
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
return res;
}
ptr++;
}
else
{
if ('"' == *ptr)
{
ptr++;
evaluate_string(&res);
if (ZBX_VARIANT_DBL == res.type && ZBX_INFINITY == res.data.dbl)
return res;
ptr++;
/* We do not really need to do this check. */
/* The only reason we do it is to keep it consistent with */
/* numeric tokens, where operators are not allowed after them: 123and. */
/* Check below ensures that '"123"and' expression will fail as well. */
if (FAIL == is_operator_delimiter(*ptr) && FAIL == is_number_delimiter(*ptr))
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" unexpected token at \"%s\".", ptr);
}
}
else
{
zbx_variant_set_dbl(&res, evaluate_number(unknown_idx));
if (ZBX_INFINITY == res.data.dbl)
{
zbx_snprintf(buffer, max_buffer_len, "Cannot evaluate expression:"
" expected numeric token at \"%s\".", ptr);
return res;
}
}
}
while ('\0' != *ptr && (' ' == *ptr || '\r' == *ptr || '\n' == *ptr || '\t' == *ptr))
ptr++;
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "-" (unary). *
* *
* -0.0 -> -0.0 *
* -1.2 -> -1.2 *
* -Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term8(int *unknown_idx)
{
while (' ' == *ptr || '\r' == *ptr || '\n' == *ptr || '\t' == *ptr)
ptr++;
if ('-' == *ptr)
{
zbx_variant_t res;
ptr++;
res = evaluate_term9(unknown_idx);
variant_convert_to_double(&res);
if (ZBX_UNKNOWN == res.data.dbl || ZBX_INFINITY == res.data.dbl)
return res;
res.data.dbl = -res.data.dbl;
return res;
}
else
return evaluate_term9(unknown_idx);
}
/******************************************************************************
* *
* Purpose: evaluate "not". *
* *
* not 0.0 -> 1.0 *
* not 1.2 -> 0.0 *
* not Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term7(int *unknown_idx)
{
while (' ' == *ptr || '\r' == *ptr || '\n' == *ptr || '\t' == *ptr)
ptr++;
if ('n' == ptr[0] && 'o' == ptr[1] && 't' == ptr[2] && SUCCEED == is_operator_delimiter(ptr[3]))
{
zbx_variant_t res;
ptr += 3;
res = evaluate_term8(unknown_idx);
variant_convert_to_double(&res);
if (ZBX_UNKNOWN == res.data.dbl || ZBX_INFINITY == res.data.dbl)
return res;
res.data.dbl = (SUCCEED == zbx_double_compare(res.data.dbl, 0.0) ? 1.0 : 0.0);
return res;
}
else
return evaluate_term8(unknown_idx);
}
/******************************************************************************
* *
* Purpose: evaluate "*" and "/". *
* *
* 0.0 * Unknown -> Unknown (yes, not 0 as we don't want to lose *
* Unknown in arithmetic operations) *
* 1.2 * Unknown -> Unknown *
* 0.0 / 1.2 -> 0.0 *
* 1.2 / 0.0 -> error (ZBX_INFINITY) *
* Unknown / 0.0 -> error (ZBX_INFINITY) *
* Unknown / 1.2 -> Unknown *
* Unknown / Unknown -> Unknown *
* 0.0 / Unknown -> Unknown *
* 1.2 / Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term6(int *unknown_idx)
{
char op;
int res_idx = -1, oper_idx = -2; /* set invalid values to catch errors */
zbx_variant_t res;
res = evaluate_term7(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term7() returns ZBX_UNKNOWN then continue as with regular number */
while ('*' == *ptr || '/' == *ptr)
{
zbx_variant_t operand;
variant_convert_to_double(&res);
if (ZBX_INFINITY == res.data.dbl)
return res;
op = *ptr++;
/* 'ZBX_UNKNOWN' in multiplication and division produces 'ZBX_UNKNOWN'. */
/* Even if 1st operand is Unknown we evaluate 2nd operand too to catch fatal errors in it. */
operand = evaluate_term7(&oper_idx);
variant_convert_to_double(&operand);
if (ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if ('*' == op)
{
if (ZBX_UNKNOWN == operand.data.dbl) /* (anything) * Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (ZBX_UNKNOWN == res.data.dbl) /* Unknown * known */
*unknown_idx = res_idx;
else
res.data.dbl *= operand.data.dbl;
}
else
{
/* catch division by 0 even if 1st operand is Unknown */
if (ZBX_UNKNOWN != operand.data.dbl && SUCCEED == zbx_double_compare(operand.data.dbl, 0.0))
{
zbx_strlcpy(buffer, "Cannot evaluate expression: division by zero.", max_buffer_len);
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if (ZBX_UNKNOWN == operand.data.dbl) /* (anything) / Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (ZBX_UNKNOWN == res.data.dbl) /* Unknown / known */
{
*unknown_idx = res_idx;
}
else
res.data.dbl /= operand.data.dbl;
}
zbx_variant_clear(&operand);
}
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "+" and "-". *
* *
* 0.0 +/- Unknown -> Unknown *
* 1.2 +/- Unknown -> Unknown *
* Unknown +/- Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term5(int *unknown_idx)
{
char op;
zbx_variant_t res, operand;
int res_idx = -3, oper_idx = -4; /* set invalid values to catch errors */
res = evaluate_term6(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term6() returns ZBX_UNKNOWN then continue as with regular number */
while ('+' == *ptr || '-' == *ptr)
{
variant_convert_to_double(&res);
if (ZBX_INFINITY == res.data.dbl)
return res;
op = *ptr++;
/* even if 1st operand is Unknown we evaluate 2nd operand to catch fatal error if any occurs */
operand = evaluate_term6(&oper_idx);
variant_convert_to_double(&operand);
if (ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if (ZBX_UNKNOWN == operand.data.dbl) /* (anything) +/- Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (ZBX_UNKNOWN == res.data.dbl) /* Unknown +/- known */
{
*unknown_idx = res_idx;
}
else
{
if ('+' == op)
res.data.dbl += operand.data.dbl;
else
res.data.dbl -= operand.data.dbl;
}
zbx_variant_clear(&operand);
}
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "<", "<=", ">=", ">". *
* *
* 0.0 < Unknown -> Unknown *
* 1.2 < Unknown -> Unknown *
* Unknown < Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term4(int *unknown_idx)
{
char op;
zbx_variant_t res, operand;
int res_idx = -5, oper_idx = -6; /* set invalid values to catch errors */
res = evaluate_term5(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term5() returns ZBX_UNKNOWN then continue as with regular number */
while (1)
{
if ('<' == ptr[0] && '=' == ptr[1])
{
op = 'l';
ptr += 2;
}
else if ('>' == ptr[0] && '=' == ptr[1])
{
op = 'g';
ptr += 2;
}
else if (('<' == ptr[0] && '>' != ptr[1]) || '>' == ptr[0])
{
op = *ptr++;
}
else
break;
variant_convert_to_double(&res);
if (ZBX_INFINITY == res.data.dbl)
return res;
/* even if 1st operand is Unknown we evaluate 2nd operand to catch fatal error if any occurs */
operand = evaluate_term5(&oper_idx);
variant_convert_to_double(&operand);
if (ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if (ZBX_UNKNOWN == operand.data.dbl) /* (anything) < Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (ZBX_UNKNOWN == res.data.dbl) /* Unknown < known */
{
*unknown_idx = res_idx;
}
else
{
if ('<' == op)
res.data.dbl = (res.data.dbl < operand.data.dbl - zbx_get_double_epsilon());
else if ('l' == op)
res.data.dbl = (res.data.dbl <= operand.data.dbl + zbx_get_double_epsilon());
else if ('g' == op)
res.data.dbl = (res.data.dbl >= operand.data.dbl - zbx_get_double_epsilon());
else
res.data.dbl = (res.data.dbl > operand.data.dbl + zbx_get_double_epsilon());
}
zbx_variant_clear(&operand);
}
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "=" and "<>". *
* *
* 0.0 = Unknown -> Unknown *
* 1.2 = Unknown -> Unknown *
* Unknown = Unknown -> Unknown *
* 0.0 <> Unknown -> Unknown *
* 1.2 <> Unknown -> Unknown *
* Unknown <> Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term3(int *unknown_idx)
{
char op;
int res_idx = -7, oper_idx = -8; /* set invalid values to catch errors */
zbx_variant_t res, operand;
double left, right, value;
res = evaluate_term4(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term4() returns ZBX_UNKNOWN then continue as with regular number */
while (1)
{
if ('=' == *ptr)
{
op = *ptr++;
}
else if ('<' == ptr[0] && '>' == ptr[1])
{
op = '#';
ptr += 2;
}
else
break;
/* even if 1st operand is Unknown we evaluate 2nd operand to catch fatal error if any occurs */
operand = evaluate_term4(&oper_idx);
if (ZBX_VARIANT_DBL == operand.type && ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
return operand;
}
if (ZBX_VARIANT_DBL == res.type && ZBX_UNKNOWN == res.data.dbl)
{
zbx_variant_clear(&operand);
continue;
}
if (ZBX_VARIANT_DBL == operand.type && ZBX_UNKNOWN == operand.data.dbl)
{
zbx_variant_clear(&res);
res = operand;
*unknown_idx = oper_idx;
continue;
}
left = variant_get_double(&res);
right = variant_get_double(&operand);
if (ZBX_INFINITY != left && ZBX_INFINITY != right)
{
/* both operands either are of double type or could be cast to it - */
/* compare them as double values */
value = (SUCCEED == zbx_double_compare(left, right) ? 1 : 0);
}
else if (ZBX_VARIANT_DBL == res.type || ZBX_VARIANT_DBL == operand.type)
{
/* if one of operands has double type and the other */
/* cannot be cast to double - they cannot be equal */
value = 0;
}
else
{
/* at this point both operands should be strings and should be */
/* compared as such but check for their types just in case */
if (ZBX_VARIANT_STR != res.type || ZBX_VARIANT_STR != operand.type)
{
zbx_strlcpy(buffer, "Cannot evaluate expression: unsupported value type found.",
max_buffer_len);
value = ZBX_INFINITY;
THIS_SHOULD_NEVER_HAPPEN;
}
else
value = !strcmp(res.data.str, operand.data.str);
}
if ('#' == op)
value = (SUCCEED == zbx_double_compare(value, 0.0) ? 1.0 : 0.0);
zbx_variant_clear(&res);
zbx_variant_clear(&operand);
zbx_variant_set_dbl(&res, value);
}
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "and". *
* *
* 0.0 and Unknown -> 0.0 *
* Unknown and 0.0 -> 0.0 *
* 1.0 and Unknown -> Unknown *
* Unknown and 1.0 -> Unknown *
* Unknown and Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term2(int *unknown_idx)
{
zbx_variant_t res, operand;
int res_idx = -9, oper_idx = -10; /* set invalid values to catch errors */
res = evaluate_term3(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term3() returns ZBX_UNKNOWN then continue as with regular number */
while ('a' == ptr[0] && 'n' == ptr[1] && 'd' == ptr[2] && SUCCEED == is_operator_delimiter(ptr[3]))
{
ptr += 3;
variant_convert_to_double(&res);
if (ZBX_INFINITY == res.data.dbl)
return res;
operand = evaluate_term3(&oper_idx);
variant_convert_to_double(&operand);
if (ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if (ZBX_UNKNOWN == res.data.dbl)
{
if (ZBX_UNKNOWN == operand.data.dbl) /* Unknown and Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (SUCCEED == zbx_double_compare(operand.data.dbl, 0.0)) /* Unknown and 0 */
{
res.data.dbl = 0.0;
}
else /* Unknown and 1 */
*unknown_idx = res_idx;
}
else if (ZBX_UNKNOWN == operand.data.dbl)
{
if (SUCCEED == zbx_double_compare(res.data.dbl, 0.0)) /* 0 and Unknown */
{
res.data.dbl = 0.0;
}
else /* 1 and Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
}
else
{
res.data.dbl = (SUCCEED != zbx_double_compare(res.data.dbl, 0.0) &&
SUCCEED != zbx_double_compare(operand.data.dbl, 0.0));
}
zbx_variant_clear(&operand);
}
return res;
}
/******************************************************************************
* *
* Purpose: evaluate "or". *
* *
* 1.0 or Unknown -> 1.0 *
* Unknown or 1.0 -> 1.0 *
* 0.0 or Unknown -> Unknown *
* Unknown or 0.0 -> Unknown *
* Unknown or Unknown -> Unknown *
* *
******************************************************************************/
static zbx_variant_t evaluate_term1(int *unknown_idx)
{
int res_idx = -11, oper_idx = -12; /* set invalid values to catch errors */
zbx_variant_t res, operand;
level++;
if (32 < level)
{
zbx_strlcpy(buffer, "Cannot evaluate expression: nesting level is too deep.", max_buffer_len);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
return res;
}
res = evaluate_term2(&res_idx);
if (ZBX_VARIANT_DBL == res.type)
{
if (ZBX_INFINITY == res.data.dbl)
return res;
if (ZBX_UNKNOWN == res.data.dbl)
*unknown_idx = res_idx;
}
/* if evaluate_term2() returns ZBX_UNKNOWN then continue as with regular number */
while ('o' == ptr[0] && 'r' == ptr[1] && SUCCEED == is_operator_delimiter(ptr[2]))
{
ptr += 2;
variant_convert_to_double(&res);
if (ZBX_INFINITY == res.data.dbl)
return res;
operand = evaluate_term2(&oper_idx);
variant_convert_to_double(&operand);
if (ZBX_INFINITY == operand.data.dbl)
{
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
zbx_variant_clear(&operand);
return res;
}
if (ZBX_UNKNOWN == res.data.dbl)
{
if (ZBX_UNKNOWN == operand.data.dbl) /* Unknown or Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
else if (SUCCEED != zbx_double_compare(operand.data.dbl, 0.0)) /* Unknown or 1 */
{
res.data.dbl = 1;
}
else /* Unknown or 0 */
*unknown_idx = res_idx;
}
else if (ZBX_UNKNOWN == operand.data.dbl)
{
if (SUCCEED != zbx_double_compare(res.data.dbl, 0.0)) /* 1 or Unknown */
{
res.data.dbl = 1;
}
else /* 0 or Unknown */
{
*unknown_idx = oper_idx;
res_idx = oper_idx;
res.data.dbl = ZBX_UNKNOWN;
}
}
else
{
res.data.dbl = (SUCCEED != zbx_double_compare(res.data.dbl, 0.0) ||
SUCCEED != zbx_double_compare(operand.data.dbl, 0.0));
}
zbx_variant_clear(&operand);
}
level--;
return res;
}
/******************************************************************************
* *
* Purpose: evaluate an expression like "(26.416>10) or (0=1)". *
* *
******************************************************************************/
int zbx_evaluate(double *value, const char *expression, char *error, size_t max_error_len,
zbx_vector_str_t *unknown_msgs)
{
int unknown_idx = -13; /* index of message in 'unknown_msgs' vector, set to invalid value */
/* to catch errors */
zbx_variant_t res;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __func__, expression);
ptr = expression;
level = 0;
buffer = error;
max_buffer_len = max_error_len;
res = evaluate_term1(&unknown_idx);
if (ZBX_VARIANT_STR == res.type)
{
if (0 == strlen(res.data.str))
{
zbx_strlcpy(buffer, "Cannot evaluate expression: unexpected end of expression.",
max_buffer_len);
zbx_variant_clear(&res);
zbx_variant_set_dbl(&res, ZBX_INFINITY);
}
else
{
variant_convert_to_double(&res);
}
}
*value = res.data.dbl;
zbx_variant_clear(&res);
if ('\0' != *ptr && ZBX_INFINITY != *value)
{
zbx_snprintf(error, max_error_len, "Cannot evaluate expression: unexpected token at \"%s\".", ptr);
*value = ZBX_INFINITY;
}
if (ZBX_UNKNOWN == *value)
{
/* Map Unknown result to error. Callers currently do not operate with ZBX_UNKNOWN. */
if (NULL != unknown_msgs)
{
if (0 > unknown_idx)
{
THIS_SHOULD_NEVER_HAPPEN;
zabbix_log(LOG_LEVEL_WARNING, "%s() internal error: " ZBX_UNKNOWN_STR " index:%d"
" expression:'%s'", __func__, unknown_idx, expression);
zbx_snprintf(error, max_error_len, "Internal error: " ZBX_UNKNOWN_STR " index %d."
" Please report this to Zabbix developers.", unknown_idx);
}
else if (unknown_msgs->values_num > unknown_idx)
{
zbx_snprintf(error, max_error_len, "Cannot evaluate expression: \"%s\".",
(char *)(unknown_msgs->values[unknown_idx]));
}
else
{
zbx_snprintf(error, max_error_len, "Cannot evaluate expression: unsupported "
ZBX_UNKNOWN_STR "%d value.", unknown_idx);
}
}
else
{
THIS_SHOULD_NEVER_HAPPEN;
/* do not leave garbage in error buffer, write something helpful */
zbx_snprintf(error, max_error_len, "%s(): internal error: no message for unknown result",
__func__);
}
*value = ZBX_INFINITY;
}
if (ZBX_INFINITY == *value)
{
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() error:'%s'", __func__, error);
return FAIL;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() value:" ZBX_FS_DBL, __func__, *value);
return SUCCEED;
}
/*******************************************************************************
* *
* Purpose: evaluate an expression like "(26.416>10) and not(0=ZBX_UNKNOWN0)". *
* *
* Parameters: expression - [IN] expression to evaluate *
* value - [OUT] expression evaluation result *
* error - [OUT] error message buffer *
* max_error_len - [IN] error buffer size *
* *
* Return value: SUCCEED - expression evaluated successfully, *
* or evaluation result is undefined (ZBX_UNKNOWN) *
* FAIL - expression evaluation failed *
* *
*******************************************************************************/
int zbx_evaluate_unknown(const char *expression, double *value, char *error, size_t max_error_len)
{
const char *__function_name = "evaluate_with_unknown";
zbx_variant_t res;
int unknown_idx = -13; /* index of message in 'unknown_msgs' vector, set to invalid value */
/* to catch errors */
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, expression);
ptr = expression;
level = 0;
buffer = error;
max_buffer_len = max_error_len;
res = evaluate_term1(&unknown_idx);
variant_convert_to_double(&res);
*value = res.data.dbl;
zbx_variant_clear(&res);
if ('\0' != *ptr && ZBX_INFINITY != *value)
{
zbx_snprintf(error, max_error_len, "Cannot evaluate expression: unexpected token at \"%s\".", ptr);
*value = ZBX_INFINITY;
}
if (ZBX_INFINITY == *value)
{
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() error:'%s'", __function_name, error);
return FAIL;
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() value:" ZBX_FS_DBL, __function_name, *value);
return SUCCEED;
}
/******************************************************************************
* *
* Purpose: cast string to a double, expand suffixes and parse negative sign. *
* *
* Parameters: in - [IN] the input string *
* *
* Return value: resulting double *
* *
******************************************************************************/
double zbx_evaluate_string_to_double(const char *in)
{
int len;
double result_double_value;
const char *tmp_ptr = in;
if (1 < strlen(in) && '-' == in[0])
tmp_ptr++;
if (SUCCEED == zbx_suffixed_number_parse(tmp_ptr, &len) && '\0' == *(tmp_ptr + len))
{
result_double_value = atof(tmp_ptr) * suffix2factor(*(tmp_ptr + len - 1));
/* negative sign detected */
if (tmp_ptr != in)
result_double_value = -(result_double_value);
}
else
{
result_double_value = ZBX_INFINITY;
}
return result_double_value;
}