3 // ----------------------------------------------------------------------------
4 // data structures for storing the parsed expression in memory
6 typedef struct eval_value {
10 calculated_number number;
11 EVAL_VARIABLE *variable;
12 struct eval_node *expression;
16 typedef struct eval_node {
18 unsigned char operator;
25 // these are used for EVAL_NODE.operator
26 // they are used as internal IDs to identify an operator
27 // THEY ARE NOT USED FOR PARSING OPERATORS LIKE THAT
28 #define EVAL_OPERATOR_NOP '\0'
29 #define EVAL_OPERATOR_EXPRESSION_OPEN '('
30 #define EVAL_OPERATOR_EXPRESSION_CLOSE ')'
31 #define EVAL_OPERATOR_NOT '!'
32 #define EVAL_OPERATOR_PLUS '+'
33 #define EVAL_OPERATOR_MINUS '-'
34 #define EVAL_OPERATOR_AND '&'
35 #define EVAL_OPERATOR_OR '|'
36 #define EVAL_OPERATOR_GREATER_THAN_OR_EQUAL 'G'
37 #define EVAL_OPERATOR_LESS_THAN_OR_EQUAL 'L'
38 #define EVAL_OPERATOR_NOT_EQUAL '~'
39 #define EVAL_OPERATOR_EQUAL '='
40 #define EVAL_OPERATOR_LESS '<'
41 #define EVAL_OPERATOR_GREATER '>'
42 #define EVAL_OPERATOR_MULTIPLY '*'
43 #define EVAL_OPERATOR_DIVIDE '/'
44 #define EVAL_OPERATOR_SIGN_PLUS 'P'
45 #define EVAL_OPERATOR_SIGN_MINUS 'M'
46 #define EVAL_OPERATOR_ABS 'A'
48 // ----------------------------------------------------------------------------
49 // forward function definitions
51 static inline void eval_node_free(EVAL_NODE *op);
52 static inline EVAL_NODE *parse_full_expression(const char **string, int *error);
53 static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error);
54 static inline calculated_number eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
55 static inline void print_parsed_as_node(BUFFER *out, EVAL_NODE *op, int *error);
56 static inline void print_parsed_as_constant(BUFFER *out, calculated_number n);
58 // ----------------------------------------------------------------------------
59 // evaluation of expressions
61 static inline calculated_number eval_check_number(calculated_number n, int *error) {
62 if(unlikely(isnan(n))) {
63 *error = EVAL_ERROR_VALUE_IS_NAN;
67 if(unlikely(isinf(n))) {
68 *error = EVAL_ERROR_VALUE_IS_INFINITE;
75 static inline calculated_number eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *v, int *error) {
76 static uint32_t this_hash = 0, now_hash = 0;
78 if(unlikely(this_hash == 0)) {
79 this_hash = simple_hash("this");
80 now_hash = simple_hash("now");
83 if(exp->this && v->hash == this_hash && !strcmp(v->name, "this")) {
84 buffer_strcat(exp->error_msg, "[ $this = ");
85 print_parsed_as_constant(exp->error_msg, *exp->this);
86 buffer_strcat(exp->error_msg, " ] ");
90 if(v->hash == now_hash && !strcmp(v->name, "now")) {
91 calculated_number n = time(NULL);
92 buffer_strcat(exp->error_msg, "[ $now = ");
93 print_parsed_as_constant(exp->error_msg, n);
94 buffer_strcat(exp->error_msg, " ] ");
99 if(exp->rrdcalc && health_variable_lookup(v->name, v->hash, exp->rrdcalc, &n)) {
100 buffer_sprintf(exp->error_msg, "[ $%s = ", v->name);
101 print_parsed_as_constant(exp->error_msg, n);
102 buffer_strcat(exp->error_msg, " ] ");
106 *error = EVAL_ERROR_UNKNOWN_VARIABLE;
107 buffer_sprintf(exp->error_msg, "unknown variable '%s'", v->name);
111 static inline calculated_number eval_value(EVAL_EXPRESSION *exp, EVAL_VALUE *v, int *error) {
115 case EVAL_VALUE_EXPRESSION:
116 n = eval_node(exp, v->expression, error);
119 case EVAL_VALUE_NUMBER:
123 case EVAL_VALUE_VARIABLE:
124 n = eval_variable(exp, v->variable, error);
128 *error = EVAL_ERROR_INVALID_VALUE;
133 // return eval_check_number(n, error);
137 calculated_number eval_and(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
138 return eval_value(exp, &op->ops[0], error) && eval_value(exp, &op->ops[1], error);
140 calculated_number eval_or(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
141 return eval_value(exp, &op->ops[0], error) || eval_value(exp, &op->ops[1], error);
143 calculated_number eval_greater_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
144 return eval_value(exp, &op->ops[0], error) >= eval_value(exp, &op->ops[1], error);
146 calculated_number eval_less_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
147 return eval_value(exp, &op->ops[0], error) <= eval_value(exp, &op->ops[1], error);
149 calculated_number eval_not_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
150 return eval_value(exp, &op->ops[0], error) != eval_value(exp, &op->ops[1], error);
152 calculated_number eval_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
153 return eval_value(exp, &op->ops[0], error) == eval_value(exp, &op->ops[1], error);
155 calculated_number eval_less(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
156 return eval_value(exp, &op->ops[0], error) < eval_value(exp, &op->ops[1], error);
158 calculated_number eval_greater(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
159 return eval_value(exp, &op->ops[0], error) > eval_value(exp, &op->ops[1], error);
161 calculated_number eval_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
162 return eval_value(exp, &op->ops[0], error) + eval_value(exp, &op->ops[1], error);
164 calculated_number eval_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
165 return eval_value(exp, &op->ops[0], error) - eval_value(exp, &op->ops[1], error);
167 calculated_number eval_multiply(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
168 return eval_value(exp, &op->ops[0], error) * eval_value(exp, &op->ops[1], error);
170 calculated_number eval_divide(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
171 return eval_value(exp, &op->ops[0], error) / eval_value(exp, &op->ops[1], error);
173 calculated_number eval_nop(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
174 return eval_value(exp, &op->ops[0], error);
176 calculated_number eval_not(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
177 return !eval_value(exp, &op->ops[0], error);
179 calculated_number eval_sign_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
180 return eval_value(exp, &op->ops[0], error);
182 calculated_number eval_sign_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
183 return -eval_value(exp, &op->ops[0], error);
185 calculated_number eval_abs(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
186 calculated_number n = eval_value(exp, &op->ops[0], error);
190 static struct operator {
191 const char *print_as;
195 calculated_number (*eval)(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
197 // this is a random access array
198 // we always access it with a known EVAL_OPERATOR_X
200 [EVAL_OPERATOR_AND] = { "&&", 2, 2, 0, eval_and },
201 [EVAL_OPERATOR_OR] = { "||", 2, 2, 0, eval_or },
202 [EVAL_OPERATOR_GREATER_THAN_OR_EQUAL] = { ">=", 3, 2, 0, eval_greater_than_or_equal },
203 [EVAL_OPERATOR_LESS_THAN_OR_EQUAL] = { "<=", 3, 2, 0, eval_less_than_or_equal },
204 [EVAL_OPERATOR_NOT_EQUAL] = { "!=", 3, 2, 0, eval_not_equal },
205 [EVAL_OPERATOR_EQUAL] = { "==", 3, 2, 0, eval_equal },
206 [EVAL_OPERATOR_LESS] = { "<", 3, 2, 0, eval_less },
207 [EVAL_OPERATOR_GREATER] = { ">", 3, 2, 0, eval_greater },
208 [EVAL_OPERATOR_PLUS] = { "+", 4, 2, 0, eval_plus },
209 [EVAL_OPERATOR_MINUS] = { "-", 4, 2, 0, eval_minus },
210 [EVAL_OPERATOR_MULTIPLY] = { "*", 5, 2, 0, eval_multiply },
211 [EVAL_OPERATOR_DIVIDE] = { "/", 5, 2, 0, eval_divide },
212 [EVAL_OPERATOR_NOT] = { "!", 6, 1, 0, eval_not },
213 [EVAL_OPERATOR_SIGN_PLUS] = { "+", 6, 1, 0, eval_sign_plus },
214 [EVAL_OPERATOR_SIGN_MINUS] = { "-", 6, 1, 0, eval_sign_minus },
215 [EVAL_OPERATOR_ABS] = { "abs(",6,1, 1, eval_abs },
216 [EVAL_OPERATOR_NOP] = { NULL, 7, 1, 0, eval_nop },
217 [EVAL_OPERATOR_EXPRESSION_OPEN] = { NULL, 7, 1, 0, eval_nop },
219 // this should exist in our evaluation list
220 [EVAL_OPERATOR_EXPRESSION_CLOSE] = { NULL, 7, 1, 0, eval_nop }
223 #define eval_precedence(operator) (operators[(unsigned char)(operator)].precedence)
225 static inline calculated_number eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
226 if(unlikely(op->count != operators[op->operator].parameters)) {
227 *error = EVAL_ERROR_INVALID_NUMBER_OF_OPERANDS;
231 calculated_number n = operators[op->operator].eval(exp, op, error);
233 // return eval_check_number(n, error);
237 // ----------------------------------------------------------------------------
238 // parsed-as generation
240 static inline void print_parsed_as_variable(BUFFER *out, EVAL_VARIABLE *v, int *error) {
242 buffer_sprintf(out, "$%s", v->name);
245 static inline void print_parsed_as_constant(BUFFER *out, calculated_number n) {
246 if(unlikely(isnan(n))) {
247 buffer_strcat(out, "nan");
251 if(unlikely(isinf(n))) {
252 buffer_strcat(out, "inf");
257 snprintfz(b, 100, CALCULATED_NUMBER_FORMAT, n);
259 s = &b[strlen(b) - 1];
260 while(s > b && *s == '0') {
265 if(s > b && *s == '.')
268 buffer_strcat(out, b);
271 static inline void print_parsed_as_value(BUFFER *out, EVAL_VALUE *v, int *error) {
273 case EVAL_VALUE_EXPRESSION:
274 print_parsed_as_node(out, v->expression, error);
277 case EVAL_VALUE_NUMBER:
278 print_parsed_as_constant(out, v->number);
281 case EVAL_VALUE_VARIABLE:
282 print_parsed_as_variable(out, v->variable, error);
286 *error = EVAL_ERROR_INVALID_VALUE;
291 static inline void print_parsed_as_node(BUFFER *out, EVAL_NODE *op, int *error) {
292 if(unlikely(op->count != operators[op->operator].parameters)) {
293 *error = EVAL_ERROR_INVALID_NUMBER_OF_OPERANDS;
297 if(operators[op->operator].parameters == 1) {
299 if(operators[op->operator].print_as)
300 buffer_sprintf(out, "%s", operators[op->operator].print_as);
302 //if(op->operator == EVAL_OPERATOR_EXPRESSION_OPEN)
303 // buffer_strcat(out, "(");
305 print_parsed_as_value(out, &op->ops[0], error);
307 //if(op->operator == EVAL_OPERATOR_EXPRESSION_OPEN)
308 // buffer_strcat(out, ")");
311 else if(operators[op->operator].parameters == 2) {
312 buffer_strcat(out, "(");
313 print_parsed_as_value(out, &op->ops[0], error);
315 if(operators[op->operator].print_as)
316 buffer_sprintf(out, " %s ", operators[op->operator].print_as);
318 print_parsed_as_value(out, &op->ops[1], error);
319 buffer_strcat(out, ")");
322 if(operators[op->operator].isfunction)
323 buffer_strcat(out, ")");
326 // ----------------------------------------------------------------------------
327 // parsing expressions
330 static inline void skip_spaces(const char **string) {
331 const char *s = *string;
332 while(isspace(*s)) s++;
336 // what character can appear just after an operator keyword
338 static inline int isoperatorterm_word(const char s) {
339 if(isspace(s) || s == '(' || s == '$' || s == '!' || s == '-' || s == '+' || isdigit(s) || !s)
345 // what character can appear just after an operator symbol?
346 static inline int isoperatorterm_symbol(const char s) {
347 if(isoperatorterm_word(s) || isalpha(s))
353 // return 1 if the character should never appear in a variable
354 static inline int isvariableterm(const char s) {
355 if(isalnum(s) || s == '.' || s == '_')
361 // ----------------------------------------------------------------------------
364 static inline int parse_and(const char **string) {
365 const char *s = *string;
368 if((s[0] == 'A' || s[0] == 'a') && (s[1] == 'N' || s[1] == 'n') && (s[2] == 'D' || s[2] == 'd') && isoperatorterm_word(s[3])) {
374 if(s[0] == '&' && s[1] == '&' && isoperatorterm_symbol(s[2])) {
382 static inline int parse_or(const char **string) {
383 const char *s = *string;
386 if((s[0] == 'O' || s[0] == 'o') && (s[1] == 'R' || s[1] == 'r') && isoperatorterm_word(s[2])) {
392 if(s[0] == '|' && s[1] == '|' && isoperatorterm_symbol(s[2])) {
400 static inline int parse_greater_than_or_equal(const char **string) {
401 const char *s = *string;
404 if(s[0] == '>' && s[1] == '=' && isoperatorterm_symbol(s[2])) {
412 static inline int parse_less_than_or_equal(const char **string) {
413 const char *s = *string;
416 if (s[0] == '<' && s[1] == '=' && isoperatorterm_symbol(s[2])) {
424 static inline int parse_greater(const char **string) {
425 const char *s = *string;
428 if(s[0] == '>' && isoperatorterm_symbol(s[1])) {
436 static inline int parse_less(const char **string) {
437 const char *s = *string;
440 if(s[0] == '<' && isoperatorterm_symbol(s[1])) {
448 static inline int parse_equal(const char **string) {
449 const char *s = *string;
452 if(s[0] == '=' && s[1] == '=' && isoperatorterm_symbol(s[2])) {
458 if(s[0] == '=' && isoperatorterm_symbol(s[1])) {
466 static inline int parse_not_equal(const char **string) {
467 const char *s = *string;
470 if(s[0] == '!' && s[1] == '=' && isoperatorterm_symbol(s[2])) {
476 if(s[0] == '<' && s[1] == '>' && isoperatorterm_symbol(s[2])) {
483 static inline int parse_not(const char **string) {
484 const char *s = *string;
487 if((s[0] == 'N' || s[0] == 'n') && (s[1] == 'O' || s[1] == 'o') && (s[2] == 'T' || s[2] == 't') && isoperatorterm_word(s[3])) {
500 static inline int parse_multiply(const char **string) {
501 const char *s = *string;
504 if(s[0] == '*' && isoperatorterm_symbol(s[1])) {
512 static inline int parse_divide(const char **string) {
513 const char *s = *string;
516 if(s[0] == '/' && isoperatorterm_symbol(s[1])) {
524 static inline int parse_minus(const char **string) {
525 const char *s = *string;
528 if(s[0] == '-' && isoperatorterm_symbol(s[1])) {
536 static inline int parse_plus(const char **string) {
537 const char *s = *string;
540 if(s[0] == '+' && isoperatorterm_symbol(s[1])) {
548 static inline int parse_open_subexpression(const char **string) {
549 const char *s = *string;
560 #define parse_close_function(x) parse_close_subexpression(x)
562 static inline int parse_close_subexpression(const char **string) {
563 const char *s = *string;
574 static inline int parse_variable(const char **string, char *buffer, size_t len) {
575 const char *s = *string;
582 while(*s && !isvariableterm(*s) && i < len)
596 static inline int parse_constant(const char **string, calculated_number *number) {
598 calculated_number n = strtold(*string, &end);
599 if(unlikely(!end || *string == end)) {
608 static inline int parse_abs(const char **string) {
609 const char *s = *string;
612 if((s[0] == 'A' || s[0] == 'a') && (s[1] == 'B' || s[1] == 'b') && (s[2] == 'S' || s[2] == 's') && s[3] == '(') {
620 static struct operator_parser {
622 int (*parse)(const char **);
623 } operator_parsers[] = {
624 // the order in this list is important!
625 // the first matching will be used
626 // so place the longer of overlapping ones
629 { EVAL_OPERATOR_AND, parse_and },
630 { EVAL_OPERATOR_OR, parse_or },
631 { EVAL_OPERATOR_GREATER_THAN_OR_EQUAL, parse_greater_than_or_equal },
632 { EVAL_OPERATOR_LESS_THAN_OR_EQUAL, parse_less_than_or_equal },
633 { EVAL_OPERATOR_NOT_EQUAL, parse_not_equal },
634 { EVAL_OPERATOR_EQUAL, parse_equal },
635 { EVAL_OPERATOR_LESS, parse_less },
636 { EVAL_OPERATOR_GREATER, parse_greater },
637 { EVAL_OPERATOR_PLUS, parse_plus },
638 { EVAL_OPERATOR_MINUS, parse_minus },
639 { EVAL_OPERATOR_MULTIPLY, parse_multiply },
640 { EVAL_OPERATOR_DIVIDE, parse_divide },
642 /* we should not put in this list the following:
648 * these are handled in code
652 { EVAL_OPERATOR_NOP, NULL }
655 static inline unsigned char parse_operator(const char **string, int *precedence) {
659 for(i = 0 ; operator_parsers[i].parse != NULL ; i++)
660 if(operator_parsers[i].parse(string)) {
661 if(precedence) *precedence = eval_precedence(operator_parsers[i].id);
662 return operator_parsers[i].id;
665 return EVAL_OPERATOR_NOP;
668 // ----------------------------------------------------------------------------
671 static inline EVAL_NODE *eval_node_alloc(int count) {
674 EVAL_NODE *op = callocz(1, sizeof(EVAL_NODE) + (sizeof(EVAL_VALUE) * count));
677 op->operator = EVAL_OPERATOR_NOP;
678 op->precedence = eval_precedence(EVAL_OPERATOR_NOP);
683 static inline void eval_node_set_value_to_node(EVAL_NODE *op, int pos, EVAL_NODE *value) {
685 fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
687 op->ops[pos].type = EVAL_VALUE_EXPRESSION;
688 op->ops[pos].expression = value;
691 static inline void eval_node_set_value_to_constant(EVAL_NODE *op, int pos, calculated_number value) {
693 fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
695 op->ops[pos].type = EVAL_VALUE_NUMBER;
696 op->ops[pos].number = value;
699 static inline void eval_node_set_value_to_variable(EVAL_NODE *op, int pos, const char *variable) {
701 fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
703 op->ops[pos].type = EVAL_VALUE_VARIABLE;
704 op->ops[pos].variable = callocz(1, sizeof(EVAL_VARIABLE));
705 op->ops[pos].variable->name = strdupz(variable);
706 op->ops[pos].variable->hash = simple_hash(op->ops[pos].variable->name);
709 static inline void eval_variable_free(EVAL_VARIABLE *v) {
714 static inline void eval_value_free(EVAL_VALUE *v) {
716 case EVAL_VALUE_EXPRESSION:
717 eval_node_free(v->expression);
720 case EVAL_VALUE_VARIABLE:
721 eval_variable_free(v->variable);
729 static inline void eval_node_free(EVAL_NODE *op) {
732 for(i = op->count - 1; i >= 0 ;i--)
733 eval_value_free(&op->ops[i]);
739 // ----------------------------------------------------------------------------
742 // helper function to avoid allocations all over the place
743 static inline EVAL_NODE *parse_next_operand_given_its_operator(const char **string, unsigned char operator_type, int *error) {
744 EVAL_NODE *sub = parse_one_full_operand(string, error);
745 if(!sub) return NULL;
747 EVAL_NODE *op = eval_node_alloc(1);
748 op->operator = operator_type;
749 eval_node_set_value_to_node(op, 0, sub);
753 // parse a full operand, including its sign or other associative operator (e.g. NOT)
754 static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error) {
755 char variable_buffer[EVAL_MAX_VARIABLE_NAME_LENGTH + 1];
756 EVAL_NODE *op1 = NULL;
757 calculated_number number;
759 *error = EVAL_ERROR_OK;
763 *error = EVAL_ERROR_MISSING_OPERAND;
767 if(parse_not(string)) {
768 op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_NOT, error);
769 op1->precedence = eval_precedence(EVAL_OPERATOR_NOT);
771 else if(parse_plus(string)) {
772 op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_SIGN_PLUS, error);
773 op1->precedence = eval_precedence(EVAL_OPERATOR_SIGN_PLUS);
775 else if(parse_minus(string)) {
776 op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_SIGN_MINUS, error);
777 op1->precedence = eval_precedence(EVAL_OPERATOR_SIGN_MINUS);
779 else if(parse_abs(string)) {
780 op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_ABS, error);
781 op1->precedence = eval_precedence(EVAL_OPERATOR_ABS);
783 else if(parse_open_subexpression(string)) {
784 EVAL_NODE *sub = parse_full_expression(string, error);
786 op1 = eval_node_alloc(1);
787 op1->operator = EVAL_OPERATOR_EXPRESSION_OPEN;
788 op1->precedence = eval_precedence(EVAL_OPERATOR_EXPRESSION_OPEN);
789 eval_node_set_value_to_node(op1, 0, sub);
790 if(!parse_close_subexpression(string)) {
791 *error = EVAL_ERROR_MISSING_CLOSE_SUBEXPRESSION;
797 else if(parse_variable(string, variable_buffer, EVAL_MAX_VARIABLE_NAME_LENGTH)) {
798 op1 = eval_node_alloc(1);
799 op1->operator = EVAL_OPERATOR_NOP;
800 eval_node_set_value_to_variable(op1, 0, variable_buffer);
802 else if(parse_constant(string, &number)) {
803 op1 = eval_node_alloc(1);
804 op1->operator = EVAL_OPERATOR_NOP;
805 eval_node_set_value_to_constant(op1, 0, number);
808 *error = EVAL_ERROR_UNKNOWN_OPERAND;
810 *error = EVAL_ERROR_MISSING_OPERAND;
815 // parse an operator and the rest of the expression
816 // precedence processing is handled here
817 static inline EVAL_NODE *parse_rest_of_expression(const char **string, int *error, EVAL_NODE *op1) {
818 EVAL_NODE *op2 = NULL;
819 unsigned char operator;
822 operator = parse_operator(string, &precedence);
825 if(operator != EVAL_OPERATOR_NOP) {
826 op2 = parse_one_full_operand(string, error);
828 // error is already reported
833 EVAL_NODE *op = eval_node_alloc(2);
834 op->operator = operator;
835 op->precedence = precedence;
837 eval_node_set_value_to_node(op, 1, op2);
839 // precedence processing
840 // if this operator has a higher precedence compared to its next
841 // put the next operator on top of us (top = evaluated later)
842 // function recursion does the rest...
843 if(op->precedence > op1->precedence && op1->count == 2 && op1->operator != '(' && op1->ops[1].type == EVAL_VALUE_EXPRESSION) {
844 eval_node_set_value_to_node(op, 0, op1->ops[1].expression);
845 op1->ops[1].expression = op;
849 eval_node_set_value_to_node(op, 0, op1);
851 return parse_rest_of_expression(string, error, op);
853 else if(**string == ')') {
857 if(op1) eval_node_free(op1);
859 *error = EVAL_ERROR_MISSING_OPERATOR;
865 // high level function to parse an expression or a sub-expression
866 static inline EVAL_NODE *parse_full_expression(const char **string, int *error) {
867 EVAL_NODE *op1 = NULL;
869 op1 = parse_one_full_operand(string, error);
871 *error = EVAL_ERROR_MISSING_OPERAND;
875 return parse_rest_of_expression(string, error, op1);
878 // ----------------------------------------------------------------------------
881 int expression_evaluate(EVAL_EXPRESSION *exp) {
882 exp->error = EVAL_ERROR_OK;
884 buffer_reset(exp->error_msg);
885 exp->result = eval_node(exp, (EVAL_NODE *)exp->nodes, &exp->error);
887 if(exp->error == EVAL_ERROR_OK)
888 exp->result = eval_check_number(exp->result, &exp->error);
890 if(exp->error != EVAL_ERROR_OK) {
893 if(buffer_strlen(exp->error_msg))
894 buffer_strcat(exp->error_msg, "; ");
896 buffer_sprintf(exp->error_msg, "failed to evaluate expression with error %d (%s)", exp->error, expression_strerror(exp->error));
903 EVAL_EXPRESSION *expression_parse(const char *string, const char **failed_at, int *error) {
904 const char *s = string;
905 int err = EVAL_ERROR_OK;
906 unsigned long pos = 0;
908 EVAL_NODE *op = parse_full_expression(&s, &err);
915 err = EVAL_ERROR_REMAINING_GARBAGE;
918 if (failed_at) *failed_at = s;
919 if (error) *error = err;
922 pos = s - string + 1;
923 error("failed to parse expression '%s': %s at character %lu (i.e.: '%s').", string, expression_strerror(err), pos, s);
927 BUFFER *out = buffer_create(1024);
928 print_parsed_as_node(out, op, &err);
929 if(err != EVAL_ERROR_OK) {
930 error("failed to re-generate expression '%s' with reason: %s", string, expression_strerror(err));
936 EVAL_EXPRESSION *exp = callocz(1, sizeof(EVAL_EXPRESSION));
938 exp->source = strdupz(string);
939 exp->parsed_as = strdupz(buffer_tostring(out));
942 exp->error_msg = buffer_create(100);
943 exp->nodes = (void *)op;
948 void expression_free(EVAL_EXPRESSION *exp) {
951 if(exp->nodes) eval_node_free((EVAL_NODE *)exp->nodes);
952 freez((void *)exp->source);
953 freez((void *)exp->parsed_as);
954 buffer_free(exp->error_msg);
958 const char *expression_strerror(int error) {
963 case EVAL_ERROR_MISSING_CLOSE_SUBEXPRESSION:
964 return "missing closing parenthesis";
966 case EVAL_ERROR_UNKNOWN_OPERAND:
967 return "unknown operand";
969 case EVAL_ERROR_MISSING_OPERAND:
970 return "expected operand";
972 case EVAL_ERROR_MISSING_OPERATOR:
973 return "expected operator";
975 case EVAL_ERROR_REMAINING_GARBAGE:
976 return "remaining characters after expression";
978 case EVAL_ERROR_INVALID_VALUE:
979 return "invalid value structure - internal error";
981 case EVAL_ERROR_INVALID_NUMBER_OF_OPERANDS:
982 return "wrong number of operands for operation - internal error";
984 case EVAL_ERROR_VALUE_IS_NAN:
985 return "value is unset";
987 case EVAL_ERROR_VALUE_IS_INFINITE:
988 return "computed value is infinite";
990 case EVAL_ERROR_UNKNOWN_VARIABLE:
991 return "undefined variable";
994 return "unknown error";