X-Git-Url: https://arthur.barton.de/gitweb/?a=blobdiff_plain;f=src%2Feval.c;h=122959ce4edb06d6ea99999838e53ec320d1046a;hb=909e26f825bc1f6f907231761412c885331fec7e;hp=e97c2b07e69c27089b31dec323dabaa0a1fe3972;hpb=6911559e3af6b73b7be8fb1171b4645121ebe1ab;p=netdata.git

diff --git a/src/eval.c b/src/eval.c
index e97c2b07..122959ce 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -44,6 +44,7 @@ typedef struct eval_node {
 #define EVAL_OPERATOR_SIGN_PLUS             'P'
 #define EVAL_OPERATOR_SIGN_MINUS            'M'
 #define EVAL_OPERATOR_ABS                   'A'
+#define EVAL_OPERATOR_IF_THEN_ELSE          '?'
 
 // ----------------------------------------------------------------------------
 // forward function definitions
@@ -58,44 +59,112 @@ static inline void print_parsed_as_constant(BUFFER *out, calculated_number n);
 // ----------------------------------------------------------------------------
 // evaluation of expressions
 
-static inline calculated_number eval_check_number(calculated_number n, int *error) {
-    if(unlikely(isnan(n))) {
-        *error = EVAL_ERROR_VALUE_IS_NAN;
-        return 0;
-    }
-
-    if(unlikely(isinf(n))) {
-        *error = EVAL_ERROR_VALUE_IS_INFINITE;
-        return 0;
-    }
-
-    return n;
-}
-
 static inline calculated_number eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *v, int *error) {
-    static uint32_t this_hash = 0, now_hash = 0;
+    static uint32_t this_hash = 0, now_hash = 0, after_hash = 0, before_hash = 0, status_hash = 0, removed_hash = 0, uninitialized_hash = 0, undefined_hash = 0, clear_hash = 0, warning_hash = 0, critical_hash = 0;
+    calculated_number n;
 
     if(unlikely(this_hash == 0)) {
         this_hash = simple_hash("this");
         now_hash = simple_hash("now");
+        after_hash = simple_hash("after");
+        before_hash = simple_hash("before");
+        status_hash = simple_hash("status");
+        removed_hash = simple_hash("REMOVED");
+        uninitialized_hash = simple_hash("UNINITIALIZED");
+        undefined_hash = simple_hash("UNDEFINED");
+        clear_hash = simple_hash("CLEAR");
+        warning_hash = simple_hash("WARNING");
+        critical_hash = simple_hash("CRITICAL");
     }
 
-    if(exp->this && v->hash == this_hash && !strcmp(v->name, "this")) {
+    if(unlikely(v->hash == this_hash && !strcmp(v->name, "this"))) {
+        n = (exp->this)?*exp->this:NAN;
         buffer_strcat(exp->error_msg, "[ $this = ");
-        print_parsed_as_constant(exp->error_msg, *exp->this);
+        print_parsed_as_constant(exp->error_msg, n);
         buffer_strcat(exp->error_msg, " ] ");
-        return *exp->this;
+        return n;
     }
 
-    if(v->hash == now_hash && !strcmp(v->name, "now")) {
-        calculated_number n = time(NULL);
+    if(unlikely(v->hash == after_hash && !strcmp(v->name, "after"))) {
+        n = (exp->after && *exp->after)?*exp->after:NAN;
+        buffer_strcat(exp->error_msg, "[ $after = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == before_hash && !strcmp(v->name, "before"))) {
+        n = (exp->before && *exp->before)?*exp->before:NAN;
+        buffer_strcat(exp->error_msg, "[ $before = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == now_hash && !strcmp(v->name, "now"))) {
+        n = now_realtime_sec();
         buffer_strcat(exp->error_msg, "[ $now = ");
         print_parsed_as_constant(exp->error_msg, n);
         buffer_strcat(exp->error_msg, " ] ");
         return n;
     }
 
-    calculated_number n;
+    if(unlikely(v->hash == status_hash && !strcmp(v->name, "status"))) {
+        n = (exp->status)?*exp->status:RRDCALC_STATUS_UNINITIALIZED;
+        buffer_strcat(exp->error_msg, "[ $status = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == removed_hash && !strcmp(v->name, "REMOVED"))) {
+        n = RRDCALC_STATUS_REMOVED;
+        buffer_strcat(exp->error_msg, "[ $REMOVED = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == uninitialized_hash && !strcmp(v->name, "UNINITIALIZED"))) {
+        n = RRDCALC_STATUS_UNINITIALIZED;
+        buffer_strcat(exp->error_msg, "[ $UNINITIALIZED = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == undefined_hash && !strcmp(v->name, "UNDEFINED"))) {
+        n = RRDCALC_STATUS_UNDEFINED;
+        buffer_strcat(exp->error_msg, "[ $UNDEFINED = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == clear_hash && !strcmp(v->name, "CLEAR"))) {
+        n = RRDCALC_STATUS_CLEAR;
+        buffer_strcat(exp->error_msg, "[ $CLEAR = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == warning_hash && !strcmp(v->name, "WARNING"))) {
+        n = RRDCALC_STATUS_WARNING;
+        buffer_strcat(exp->error_msg, "[ $WARNING = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
+    if(unlikely(v->hash == critical_hash && !strcmp(v->name, "CRITICAL"))) {
+        n = RRDCALC_STATUS_CRITICAL;
+        buffer_strcat(exp->error_msg, "[ $CRITICAL = ");
+        print_parsed_as_constant(exp->error_msg, n);
+        buffer_strcat(exp->error_msg, " ] ");
+        return n;
+    }
+
     if(exp->rrdcalc && health_variable_lookup(v->name, v->hash, exp->rrdcalc, &n)) {
         buffer_sprintf(exp->error_msg, "[ $%s = ", v->name);
         print_parsed_as_constant(exp->error_msg, n);
@@ -104,7 +173,7 @@ static inline calculated_number eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABL
     }
 
     *error = EVAL_ERROR_UNKNOWN_VARIABLE;
-    buffer_sprintf(exp->error_msg, "unknown variable '%s'", v->name);
+    buffer_sprintf(exp->error_msg, "[ undefined variable '%s' ] ", v->name);
     return 0;
 }
 
@@ -130,61 +199,108 @@ static inline calculated_number eval_value(EVAL_EXPRESSION *exp, EVAL_VALUE *v,
             break;
     }
 
-    // return eval_check_number(n, error);
     return n;
 }
 
+static inline int is_true(calculated_number n) {
+    if(isnan(n)) return 0;
+    if(isinf(n)) return 1;
+    if(n == 0) return 0;
+    return 1;
+}
+
 calculated_number eval_and(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) && eval_value(exp, &op->ops[1], error);
+    return is_true(eval_value(exp, &op->ops[0], error)) && is_true(eval_value(exp, &op->ops[1], error));
 }
 calculated_number eval_or(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) || eval_value(exp, &op->ops[1], error);
+    return is_true(eval_value(exp, &op->ops[0], error)) || is_true(eval_value(exp, &op->ops[1], error));
 }
 calculated_number eval_greater_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) >= eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    return isgreaterequal(n1, n2);
 }
 calculated_number eval_less_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) <= eval_value(exp, &op->ops[1], error);
-}
-calculated_number eval_not_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) != eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    return islessequal(n1, n2);
 }
 calculated_number eval_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) == eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    if(isnan(n1) && isnan(n2)) return 1;
+    if(isinf(n1) && isinf(n2)) return 1;
+    if(isnan(n1) || isnan(n2)) return 0;
+    if(isinf(n1) || isinf(n2)) return 0;
+    return n1 == n2;
+}
+calculated_number eval_not_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
+    return !eval_equal(exp, op, error);
 }
 calculated_number eval_less(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) < eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    return isless(n1, n2);
 }
 calculated_number eval_greater(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) > eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    return isgreater(n1, n2);
 }
 calculated_number eval_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) + eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    if(isnan(n1) || isnan(n2)) return NAN;
+    if(isinf(n1) || isinf(n2)) return INFINITY;
+    return n1 + n2;
 }
 calculated_number eval_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) - eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    if(isnan(n1) || isnan(n2)) return NAN;
+    if(isinf(n1) || isinf(n2)) return INFINITY;
+    return n1 - n2;
 }
 calculated_number eval_multiply(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) * eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    if(isnan(n1) || isnan(n2)) return NAN;
+    if(isinf(n1) || isinf(n2)) return INFINITY;
+    return n1 * n2;
 }
 calculated_number eval_divide(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return eval_value(exp, &op->ops[0], error) / eval_value(exp, &op->ops[1], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    calculated_number n2 = eval_value(exp, &op->ops[1], error);
+    if(isnan(n1) || isnan(n2)) return NAN;
+    if(isinf(n1) || isinf(n2)) return INFINITY;
+    return n1 / n2;
 }
 calculated_number eval_nop(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
     return eval_value(exp, &op->ops[0], error);
 }
 calculated_number eval_not(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return !eval_value(exp, &op->ops[0], error);
+    return !is_true(eval_value(exp, &op->ops[0], error));
 }
 calculated_number eval_sign_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
     return eval_value(exp, &op->ops[0], error);
 }
 calculated_number eval_sign_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    return -eval_value(exp, &op->ops[0], error);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    if(isnan(n1)) return NAN;
+    if(isinf(n1)) return INFINITY;
+    return -n1;
 }
 calculated_number eval_abs(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
-    calculated_number n = eval_value(exp, &op->ops[0], error);
-    return abs(n);
+    calculated_number n1 = eval_value(exp, &op->ops[0], error);
+    if(isnan(n1)) return NAN;
+    if(isinf(n1)) return INFINITY;
+    return abs(n1);
+}
+calculated_number eval_if_then_else(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
+    if(is_true(eval_value(exp, &op->ops[0], error)))
+        return eval_value(exp, &op->ops[1], error);
+    else
+        return eval_value(exp, &op->ops[2], error);
 }
 
 static struct operator {
@@ -213,11 +329,12 @@ static struct operator {
         [EVAL_OPERATOR_SIGN_PLUS]             = { "+",  6, 1, 0, eval_sign_plus },
         [EVAL_OPERATOR_SIGN_MINUS]            = { "-",  6, 1, 0, eval_sign_minus },
         [EVAL_OPERATOR_ABS]                   = { "abs(",6,1, 1, eval_abs },
-        [EVAL_OPERATOR_NOP]                   = { NULL, 7, 1, 0, eval_nop },
-        [EVAL_OPERATOR_EXPRESSION_OPEN]       = { NULL, 7, 1, 0, eval_nop },
+        [EVAL_OPERATOR_IF_THEN_ELSE]          = { "?",  7, 3, 0, eval_if_then_else },
+        [EVAL_OPERATOR_NOP]                   = { NULL, 8, 1, 0, eval_nop },
+        [EVAL_OPERATOR_EXPRESSION_OPEN]       = { NULL, 8, 1, 0, eval_nop },
 
         // this should exist in our evaluation list
-        [EVAL_OPERATOR_EXPRESSION_CLOSE]      = { NULL, 7, 1, 0, eval_nop }
+        [EVAL_OPERATOR_EXPRESSION_CLOSE]      = { NULL, 99, 1, 0, eval_nop }
 };
 
 #define eval_precedence(operator) (operators[(unsigned char)(operator)].precedence)
@@ -230,7 +347,6 @@ static inline calculated_number eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, i
 
     calculated_number n = operators[op->operator].eval(exp, op, error);
 
-    // return eval_check_number(n, error);
     return n;
 }
 
@@ -318,6 +434,18 @@ static inline void print_parsed_as_node(BUFFER *out, EVAL_NODE *op, int *error)
         print_parsed_as_value(out, &op->ops[1], error);
         buffer_strcat(out, ")");
     }
+    else if(op->operator == EVAL_OPERATOR_IF_THEN_ELSE && operators[op->operator].parameters == 3) {
+        buffer_strcat(out, "(");
+        print_parsed_as_value(out, &op->ops[0], error);
+
+        if(operators[op->operator].print_as)
+            buffer_sprintf(out, " %s ", operators[op->operator].print_as);
+
+        print_parsed_as_value(out, &op->ops[1], error);
+        buffer_strcat(out, " : ");
+        print_parsed_as_value(out, &op->ops[2], error);
+        buffer_strcat(out, ")");
+    }
 
     if(operators[op->operator].isfunction)
         buffer_strcat(out, ")");
@@ -617,6 +745,18 @@ static inline int parse_abs(const char **string) {
     return 0;
 }
 
+static inline int parse_if_then_else(const char **string) {
+    const char *s = *string;
+
+    // ?
+    if(s[0] == '?') {
+        *string = &s[1];
+        return 1;
+    }
+
+    return 0;
+}
+
 static struct operator_parser {
     unsigned char id;
     int (*parse)(const char **);
@@ -638,6 +778,7 @@ static struct operator_parser {
         { EVAL_OPERATOR_MINUS,                 parse_minus },
         { EVAL_OPERATOR_MULTIPLY,              parse_multiply },
         { EVAL_OPERATOR_DIVIDE,                parse_divide },
+        { EVAL_OPERATOR_IF_THEN_ELSE,          parse_if_then_else },
 
         /* we should not put in this list the following:
          *
@@ -830,10 +971,36 @@ static inline EVAL_NODE *parse_rest_of_expression(const char **string, int *erro
             return NULL;
         }
 
-        EVAL_NODE *op = eval_node_alloc(2);
+        EVAL_NODE *op = eval_node_alloc(operators[operator].parameters);
         op->operator = operator;
         op->precedence = precedence;
 
+        if(operator == EVAL_OPERATOR_IF_THEN_ELSE && op->count == 3) {
+            skip_spaces(string);
+
+            if(**string != ':') {
+                eval_node_free(op);
+                eval_node_free(op1);
+                eval_node_free(op2);
+                *error = EVAL_ERROR_IF_THEN_ELSE_MISSING_ELSE;
+                return NULL;
+            }
+            (*string)++;
+
+            skip_spaces(string);
+
+            EVAL_NODE *op3 = parse_one_full_operand(string, error);
+            if(!op3) {
+                eval_node_free(op);
+                eval_node_free(op1);
+                eval_node_free(op2);
+                // error is already reported
+                return NULL;
+            }
+
+            eval_node_set_value_to_node(op, 2, op3);
+        }
+
         eval_node_set_value_to_node(op, 1, op2);
 
         // precedence processing
@@ -854,7 +1021,7 @@ static inline EVAL_NODE *parse_rest_of_expression(const char **string, int *erro
         ;
     }
     else if(**string) {
-        if(op1) eval_node_free(op1);
+        eval_node_free(op1);
         op1 = NULL;
         *error = EVAL_ERROR_MISSING_OPERATOR;
     }
@@ -864,9 +1031,7 @@ static inline EVAL_NODE *parse_rest_of_expression(const char **string, int *erro
 
 // high level function to parse an expression or a sub-expression
 static inline EVAL_NODE *parse_full_expression(const char **string, int *error) {
-    EVAL_NODE *op1 = NULL;
-
-    op1 = parse_one_full_operand(string, error);
+    EVAL_NODE *op1 = parse_one_full_operand(string, error);
     if(!op1) {
         *error = EVAL_ERROR_MISSING_OPERAND;
         return NULL;
@@ -884,8 +1049,19 @@ int expression_evaluate(EVAL_EXPRESSION *exp) {
     buffer_reset(exp->error_msg);
     exp->result = eval_node(exp, (EVAL_NODE *)exp->nodes, &exp->error);
 
-    if(exp->error == EVAL_ERROR_OK)
-        exp->result = eval_check_number(exp->result, &exp->error);
+    if(unlikely(isnan(exp->result))) {
+        if(exp->error == EVAL_ERROR_OK)
+            exp->error = EVAL_ERROR_VALUE_IS_NAN;
+    }
+    else if(unlikely(isinf(exp->result))) {
+        if(exp->error == EVAL_ERROR_OK)
+            exp->error = EVAL_ERROR_VALUE_IS_INFINITE;
+    }
+    else if(unlikely(exp->error == EVAL_ERROR_UNKNOWN_VARIABLE)) {
+        // although there is an unknown variable
+        // the expression was evaluated successfully
+        exp->error = EVAL_ERROR_OK;
+    }
 
     if(exp->error != EVAL_ERROR_OK) {
         exp->result = NAN;
@@ -903,7 +1079,6 @@ int expression_evaluate(EVAL_EXPRESSION *exp) {
 EVAL_EXPRESSION *expression_parse(const char *string, const char **failed_at, int *error) {
     const char *s = string;
     int err = EVAL_ERROR_OK;
-    unsigned long pos = 0;
 
     EVAL_NODE *op = parse_full_expression(&s, &err);
 
@@ -919,7 +1094,7 @@ EVAL_EXPRESSION *expression_parse(const char *string, const char **failed_at, in
     if (error) *error = err;
 
     if(!op) {
-        pos = s - string + 1;
+        unsigned long pos = s - string + 1;
         error("failed to parse expression '%s': %s at character %lu (i.e.: '%s').", string, expression_strerror(err), pos, s);
         return NULL;
     }
@@ -990,6 +1165,9 @@ const char *expression_strerror(int error) {
         case EVAL_ERROR_UNKNOWN_VARIABLE:
             return "undefined variable";
 
+        case EVAL_ERROR_IF_THEN_ELSE_MISSING_ELSE:
+            return "missing second sub-expression of inline conditional";
+
         default:
             return "unknown error";
     }