various renames to make the code more readable
Costa Tsaousis committed
Aug 11, 2016 at 01:11 UTC
69f67772dbb538726a90dfb6e8a9450cae580695
3 files changed
+134
-132
profile/test-eval.c
+16
-16
@@ -18,45 +18,45 @@ void indent(int level, int show) {
18
else printf(" \\_ ");
19
}
20
21
-void print_operand(EVAL_OPERAND *op, int level);
21
+void print_node(EVAL_NODE *op, int level);
22
23
void print_value(EVAL_VALUE *v, int level) {
24
indent(level, 0);
25
26
switch(v->type) {
27
case EVAL_VALUE_INVALID:
28
- printf("VALUE (NOP)\n");
28
+ printf("value (NOP)\n");
29
break;
30
31
case EVAL_VALUE_NUMBER:
32
- printf("VALUE %Lf (NUMBER)\n", v->number);
32
+ printf("value %Lf (NUMBER)\n", v->number);
33
break;
34
35
case EVAL_VALUE_EXPRESSION:
36
- printf("VALUE (SUB-EXPRESSION)\n");
37
- print_operand(v->expression, level+1);
36
+ printf("value (SUB-EXPRESSION)\n");
37
+ print_node(v->expression, level+1);
38
break;
39
40
default:
41
- printf("VALUE (INVALID type %d)\n", v->type);
41
+ printf("value (INVALID type %d)\n", v->type);
42
break;
43
44
}
45
}
46
47
-void print_operand(EVAL_OPERAND *op, int level) {
47
+void print_node(EVAL_NODE *op, int level) {
48
49
// if(op->operator != EVAL_OPERATOR_NOP) {
50
indent(level, 1);
51
- if(op->operator) printf("%c (OPERATOR %d, prec: %d)\n", op->operator, op->id, op->precedence);
52
- else printf("NOP (OPERATOR %d, prec: %d)\n", op->id, op->precedence);
51
+ if(op->operator) printf("%c (node %d, precedence: %d)\n", op->operator, op->id, op->precedence);
52
+ else printf("NOP (node %d, precedence: %d)\n", op->id, op->precedence);
53
// }
54
55
int i = op->count;
56
while(i--) print_value(&op->ops[i], level + 1);
57
}
58
59
-calculated_number evaluate(EVAL_OPERAND *op, int depth);
59
+calculated_number evaluate(EVAL_NODE *op, int depth);
60
61
calculated_number evaluate_value(EVAL_VALUE *v, int depth) {
62
switch(v->type) {
@@ -78,7 +78,7 @@ void print_depth(int depth) {
78
while(depth--) printf(" ");
79
}
80
81
-calculated_number evaluate(EVAL_OPERAND *op, int depth) {
81
+calculated_number evaluate(EVAL_NODE *op, int depth) {
82
calculated_number n1, n2, r;
83
84
switch(op->operator) {
@@ -237,19 +237,19 @@ calculated_number evaluate(EVAL_OPERAND *op, int depth) {
237
return r;
238
}
239
240
-void print_expression(EVAL_OPERAND *op, const char *failed_at, int error) {
240
+void print_expression(EVAL_NODE *op, const char *failed_at, int error) {
241
if(op) {
242
printf("expression tree:\n");
243
- print_operand(op, 0);
243
+ print_node(op, 0);
244
245
printf("\nevaluation steps:\n");
246
evaluate(op, 0);
247
248
int error;
249
- calculated_number ret = evaluate_expression(op, &error);
249
+ calculated_number ret = expression_evaluate(op, &error);
250
printf("\ninternal evaluator:\nSTATUS: %d, RESULT = %Lf\n", error, ret);
251
252
- free_expression(op);
252
+ expression_free(op);
253
}
254
else {
255
printf("error: %d, failed_at: '%s'\n", error, (failed_at)?failed_at:"<NONE>");
@@ -265,7 +265,7 @@ int main(int argc, char **argv) {
265
266
const char *failed_at = NULL;
267
int error;
268
- EVAL_OPERAND *op = parse_expression(argv[1], &failed_at, &error);
268
+ EVAL_NODE *op = expression_parse(argv[1], &failed_at, &error);
269
print_expression(op, failed_at, error);
270
return 0;
271
}
src/eval.c
+110
-109
@@ -1,11 +1,10 @@
1
#include "common.h"
2
3
// forward definitions
4
-static inline void operand_free(EVAL_OPERAND *op);
5
-static inline EVAL_OPERAND *parse_operand(const char **string, int *error);
6
-static inline EVAL_OPERAND *parse_operand1(const char **string, int *error);
7
-static inline calculated_number eval_operand(EVAL_OPERAND *op, int *error);
8
-
4
+static inline void eval_node_free(EVAL_NODE *op);
5
+static inline EVAL_NODE *parse_full_expression(const char **string, int *error);
6
+static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error);
7
+static inline calculated_number eval_node(EVAL_NODE *op, int *error);
8
9
static inline void skip_spaces(const char **string) {
10
const char *s = *string;
@@ -217,7 +216,7 @@ static inline int parse_close_subexpression(const char **string) {
216
return 0;
217
}
218
220
-static inline int parse_literal(const char **string, calculated_number *number) {
219
+static inline int parse_constant(const char **string, calculated_number *number) {
220
char *end = NULL;
221
calculated_number n = strtold(*string, &end);
222
if(unlikely(!end || *string == end || isnan(n) || isinf(n))) {
@@ -225,7 +224,6 @@ static inline int parse_literal(const char **string, calculated_number *number)
224
return 0;
225
}
226
*number = n;
228
-
227
*string = end;
228
return 1;
229
}
@@ -251,7 +249,7 @@ static inline int parse_not(const char **string) {
249
}
250
251
static struct operator_parser {
254
- char id;
252
+ unsigned char id;
253
int (*parse)(const char **);
254
} operator_parsers[] = {
255
// the order in this list is important!
@@ -272,13 +270,13 @@ static struct operator_parser {
270
{ EVAL_OPERATOR_MULTIPLY, parse_multiply },
271
{ EVAL_OPERATOR_DIVIDE, parse_divide },
272
275
- /* we should not put
273
+ /* we should not put in this list the following:
274
*
275
* - NOT
276
* - (
277
* - )
278
*
281
- * in this list
279
+ * these are handled in code
280
*/
281
282
{ EVAL_OPERATOR_NOP, NULL }
@@ -306,7 +304,7 @@ static inline calculated_number eval_value(EVAL_VALUE *v, int *error) {
304
305
switch(v->type) {
306
case EVAL_VALUE_EXPRESSION:
309
- n = eval_operand(v->expression, error);
307
+ n = eval_node(v->expression, error);
308
break;
309
310
case EVAL_VALUE_NUMBER:
@@ -325,52 +323,52 @@ static inline calculated_number eval_value(EVAL_VALUE *v, int *error) {
323
return eval_check_number(n, error);
324
}
325
328
-calculated_number eval_and(EVAL_OPERAND *op, int *error) {
326
+calculated_number eval_and(EVAL_NODE *op, int *error) {
327
return eval_value(&op->ops[0], error) && eval_value(&op->ops[1], error);
328
}
331
-calculated_number eval_or(EVAL_OPERAND *op, int *error) {
329
+calculated_number eval_or(EVAL_NODE *op, int *error) {
330
return eval_value(&op->ops[0], error) || eval_value(&op->ops[1], error);
331
}
334
-calculated_number eval_greater_than_or_equal(EVAL_OPERAND *op, int *error) {
332
+calculated_number eval_greater_than_or_equal(EVAL_NODE *op, int *error) {
333
return eval_value(&op->ops[0], error) >= eval_value(&op->ops[1], error);
334
}
337
-calculated_number eval_less_than_or_equal(EVAL_OPERAND *op, int *error) {
335
+calculated_number eval_less_than_or_equal(EVAL_NODE *op, int *error) {
336
return eval_value(&op->ops[0], error) <= eval_value(&op->ops[1], error);
337
}
340
-calculated_number eval_not_equal(EVAL_OPERAND *op, int *error) {
338
+calculated_number eval_not_equal(EVAL_NODE *op, int *error) {
339
return eval_value(&op->ops[0], error) != eval_value(&op->ops[1], error);
340
}
343
-calculated_number eval_equal(EVAL_OPERAND *op, int *error) {
341
+calculated_number eval_equal(EVAL_NODE *op, int *error) {
342
return eval_value(&op->ops[0], error) == eval_value(&op->ops[1], error);
343
}
346
-calculated_number eval_less(EVAL_OPERAND *op, int *error) {
344
+calculated_number eval_less(EVAL_NODE *op, int *error) {
345
return eval_value(&op->ops[0], error) < eval_value(&op->ops[1], error);
346
}
349
-calculated_number eval_greater(EVAL_OPERAND *op, int *error) {
347
+calculated_number eval_greater(EVAL_NODE *op, int *error) {
348
return eval_value(&op->ops[0], error) > eval_value(&op->ops[1], error);
349
}
352
-calculated_number eval_plus(EVAL_OPERAND *op, int *error) {
350
+calculated_number eval_plus(EVAL_NODE *op, int *error) {
351
return eval_value(&op->ops[0], error) + eval_value(&op->ops[1], error);
352
}
355
-calculated_number eval_minus(EVAL_OPERAND *op, int *error) {
353
+calculated_number eval_minus(EVAL_NODE *op, int *error) {
354
return eval_value(&op->ops[0], error) - eval_value(&op->ops[1], error);
355
}
358
-calculated_number eval_multiply(EVAL_OPERAND *op, int *error) {
356
+calculated_number eval_multiply(EVAL_NODE *op, int *error) {
357
return eval_value(&op->ops[0], error) * eval_value(&op->ops[1], error);
358
}
361
-calculated_number eval_divide(EVAL_OPERAND *op, int *error) {
359
+calculated_number eval_divide(EVAL_NODE *op, int *error) {
360
return eval_value(&op->ops[0], error) / eval_value(&op->ops[1], error);
361
}
364
-calculated_number eval_nop(EVAL_OPERAND *op, int *error) {
362
+calculated_number eval_nop(EVAL_NODE *op, int *error) {
363
return eval_value(&op->ops[0], error);
364
}
367
-calculated_number eval_not(EVAL_OPERAND *op, int *error) {
365
+calculated_number eval_not(EVAL_NODE *op, int *error) {
366
return !eval_value(&op->ops[0], error);
367
}
370
-calculated_number eval_sign_plus(EVAL_OPERAND *op, int *error) {
368
+calculated_number eval_sign_plus(EVAL_NODE *op, int *error) {
369
return eval_value(&op->ops[0], error);
370
}
373
-calculated_number eval_sign_minus(EVAL_OPERAND *op, int *error) {
371
+calculated_number eval_sign_minus(EVAL_NODE *op, int *error) {
372
return -eval_value(&op->ops[0], error);
373
}
374
@@ -378,7 +376,7 @@ static struct operator {
376
const char *print_as;
377
char precedence;
378
char parameters;
381
- calculated_number (*eval)(EVAL_OPERAND *op, int *error);
379
+ calculated_number (*eval)(EVAL_NODE *op, int *error);
380
} operators[256] = {
381
// this is a random access array
382
// we always access it with a known EVAL_OPERATOR_X
@@ -408,7 +406,7 @@ static struct operator {
406
407
#define eval_precedence(operator) (operators[(unsigned char)(operator)].precedence)
408
411
-static inline calculated_number eval_operand(EVAL_OPERAND *op, int *error) {
409
+static inline calculated_number eval_node(EVAL_NODE *op, int *error) {
410
if(unlikely(op->count != operators[op->operator].parameters)) {
411
*error = EVAL_ERROR_INVALID_NUMBER_OF_OPERANDS;
412
return 0;
@@ -421,7 +419,7 @@ static inline calculated_number eval_operand(EVAL_OPERAND *op, int *error) {
419
420
// ----------------------------------------------------------------------------
421
424
-static inline char parse_operator(const char **string, int *precedence) {
422
+static inline unsigned char parse_operator(const char **string, int *precedence) {
423
skip_spaces(string);
424
425
int i;
@@ -434,11 +432,10 @@ static inline char parse_operator(const char **string, int *precedence) {
432
return EVAL_OPERATOR_NOP;
433
}
434
437
-
438
-static inline EVAL_OPERAND *operand_alloc(int count) {
435
+static inline EVAL_NODE *eval_node_alloc(int count) {
436
static int id = 1;
437
441
- EVAL_OPERAND *op = calloc(1, sizeof(EVAL_OPERAND) + (sizeof(EVAL_VALUE) * count));
438
+ EVAL_NODE *op = calloc(1, sizeof(EVAL_NODE) + (sizeof(EVAL_VALUE) * count));
439
if(!op) fatal("Cannot allocate memory for OPERAND with %d slots", count);
440
441
op->id = id++;
@@ -448,7 +445,7 @@ static inline EVAL_OPERAND *operand_alloc(int count) {
445
return op;
446
}
447
451
-static inline void operand_set_value_operand(EVAL_OPERAND *op, int pos, EVAL_OPERAND *value) {
448
+static inline void eval_node_set_value_to_node(EVAL_NODE *op, int pos, EVAL_NODE *value) {
449
if(pos >= op->count)
450
fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
451
@@ -456,7 +453,7 @@ static inline void operand_set_value_operand(EVAL_OPERAND *op, int pos, EVAL_OPE
453
op->ops[pos].expression = value;
454
}
455
459
-static inline void operand_set_value_literal(EVAL_OPERAND *op, int pos, calculated_number value) {
456
+static inline void node_set_value_to_constant(EVAL_NODE *op, int pos, calculated_number value) {
457
if(pos >= op->count)
458
fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
459
@@ -471,19 +468,19 @@ static inline void variable_free(VARIABLE *v) {
468
static inline void value_free(EVAL_VALUE *v) {
469
switch(v->type) {
470
case EVAL_VALUE_EXPRESSION:
474
- operand_free(v->expression);
471
+ eval_node_free(v->expression);
472
break;
473
477
- case EVAL_VALUE_VARIABLE:
478
- variable_free(v->variable);
479
- break;
474
+// case EVAL_VALUE_VARIABLE:
475
+// variable_free(v->variable);
476
+// break;
477
478
default:
479
break;
480
}
481
}
482
486
-static inline void operand_free(EVAL_OPERAND *op) {
483
+static inline void eval_node_free(EVAL_NODE *op) {
484
if(op->count) {
485
int i;
486
for(i = op->count - 1; i >= 0 ;i--)
@@ -493,18 +490,18 @@ static inline void operand_free(EVAL_OPERAND *op) {
490
free(op);
491
}
492
496
-static inline EVAL_OPERAND *parse_operand_with_operator(const char **string, char type, int *error) {
497
- EVAL_OPERAND *sub = parse_operand1(string, error);
493
+static inline EVAL_NODE *parse_next_operand_given_its_operator(const char **string, unsigned char operator_type, int *error) {
494
+ EVAL_NODE *sub = parse_one_full_operand(string, error);
495
if(!sub) return NULL;
496
500
- EVAL_OPERAND *op = operand_alloc(1);
501
- op->operator = type;
502
- operand_set_value_operand(op, 0, sub);
497
+ EVAL_NODE *op = eval_node_alloc(1);
498
+ op->operator = operator_type;
499
+ eval_node_set_value_to_node(op, 0, sub);
500
return op;
501
}
502
506
-static inline EVAL_OPERAND *parse_operand1(const char **string, int *error) {
507
- EVAL_OPERAND *op1 = NULL;
503
+static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error) {
504
+ EVAL_NODE *op1 = NULL;
505
calculated_number number;
506
507
*error = EVAL_ERROR_OK;
@@ -516,27 +513,27 @@ static inline EVAL_OPERAND *parse_operand1(const char **string, int *error) {
513
}
514
515
if(parse_not(string)) {
519
- op1 = parse_operand_with_operator(string, EVAL_OPERATOR_NOT, error);
516
+ op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_NOT, error);
517
op1->precedence = eval_precedence(EVAL_OPERATOR_NOT);
518
}
519
else if(parse_plus(string)) {
523
- op1 = parse_operand_with_operator(string, EVAL_OPERATOR_SIGN_PLUS, error);
520
+ op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_SIGN_PLUS, error);
521
op1->precedence = eval_precedence(EVAL_OPERATOR_SIGN_PLUS);
522
}
523
else if(parse_minus(string)) {
527
- op1 = parse_operand_with_operator(string, EVAL_OPERATOR_SIGN_MINUS, error);
524
+ op1 = parse_next_operand_given_its_operator(string, EVAL_OPERATOR_SIGN_MINUS, error);
525
op1->precedence = eval_precedence(EVAL_OPERATOR_SIGN_MINUS);
526
}
527
else if(parse_open_subexpression(string)) {
531
- EVAL_OPERAND *sub = parse_operand(string, error);
528
+ EVAL_NODE *sub = parse_full_expression(string, error);
529
if(sub) {
533
- op1 = operand_alloc(1);
530
+ op1 = eval_node_alloc(1);
531
op1->operator = EVAL_OPERATOR_EXPRESSION_OPEN;
532
op1->precedence = eval_precedence(EVAL_OPERATOR_EXPRESSION_OPEN);
536
- operand_set_value_operand(op1, 0, sub);
533
+ eval_node_set_value_to_node(op1, 0, sub);
534
if(!parse_close_subexpression(string)) {
535
*error = EVAL_ERROR_MISSING_CLOSE_SUBEXPRESSION;
539
- operand_free(op1);
536
+ eval_node_free(op1);
537
return NULL;
538
}
539
}
@@ -544,10 +541,10 @@ static inline EVAL_OPERAND *parse_operand1(const char **string, int *error) {
541
// else if(parse_variable(string)) {
542
//
543
// }
547
- else if(parse_literal(string, &number)) {
548
- op1 = operand_alloc(1);
544
+ else if(parse_constant(string, &number)) {
545
+ op1 = eval_node_alloc(1);
546
op1->operator = EVAL_OPERATOR_VALUE;
550
- operand_set_value_literal(op1, 0, number);
547
+ node_set_value_to_constant(op1, 0, number);
548
}
549
else if(*string)
550
*error = EVAL_ERROR_UNKNOWN_OPERAND;
@@ -557,41 +554,42 @@ static inline EVAL_OPERAND *parse_operand1(const char **string, int *error) {
554
return op1;
555
}
556
560
-static inline EVAL_OPERAND *parse_operand_rest(const char **string, int *error, EVAL_OPERAND *op1) {
561
- EVAL_OPERAND *op2 = NULL;
562
- char operator;
557
+static inline EVAL_NODE *parse_rest_of_expression(const char **string, int *error, EVAL_NODE *op1) {
558
+ EVAL_NODE *op2 = NULL;
559
+ unsigned char operator;
560
int precedence;
561
562
operator = parse_operator(string, &precedence);
563
skip_spaces(string);
564
565
if(operator != EVAL_OPERATOR_NOP) {
569
- op2 = parse_operand1(string, error);
566
+ op2 = parse_one_full_operand(string, error);
567
if(!op2) {
571
- operand_free(op1);
568
+ // error is already reported
569
+ eval_node_free(op1);
570
return NULL;
571
}
572
575
- EVAL_OPERAND *op = operand_alloc(2);
573
+ EVAL_NODE *op = eval_node_alloc(2);
574
op->operator = operator;
575
op->precedence = precedence;
576
579
- operand_set_value_operand(op, 0, op1);
580
- operand_set_value_operand(op, 1, op2);
577
+ eval_node_set_value_to_node(op, 0, op1);
578
+ eval_node_set_value_to_node(op, 1, op2);
579
580
if(op->precedence > op1->precedence && op1->count == 2 && op1->operator != '(' && op1->ops[1].type == EVAL_VALUE_EXPRESSION) {
583
- operand_set_value_operand(op, 0, op1->ops[1].expression);
581
+ eval_node_set_value_to_node(op, 0, op1->ops[1].expression);
582
op1->ops[1].expression = op;
583
op = op1;
584
}
585
588
- return parse_operand_rest(string, error, op);
586
+ return parse_rest_of_expression(string, error, op);
587
}
588
else if(**string == EVAL_OPERATOR_EXPRESSION_CLOSE) {
589
;
590
}
591
else if(**string) {
594
- if(op1) operand_free(op1);
592
+ if(op1) eval_node_free(op1);
593
op1 = NULL;
594
*error = EVAL_ERROR_MISSING_OPERATOR;
595
}
@@ -599,19 +597,58 @@ static inline EVAL_OPERAND *parse_operand_rest(const char **string, int *error,
597
return op1;
598
}
599
602
-static inline EVAL_OPERAND *parse_operand(const char **string, int *error) {
603
- EVAL_OPERAND *op1 = NULL;
600
+static inline EVAL_NODE *parse_full_expression(const char **string, int *error) {
601
+ EVAL_NODE *op1 = NULL;
602
605
- op1 = parse_operand1(string, error);
603
+ op1 = parse_one_full_operand(string, error);
604
if(!op1) {
605
*error = EVAL_ERROR_MISSING_OPERAND;
606
return NULL;
607
}
608
611
- return parse_operand_rest(string, error, op1);
609
+ return parse_rest_of_expression(string, error, op1);
610
+}
611
+
612
+// ----------------------------------------------------------------------------
613
+// public API
614
+
615
+EVAL_NODE *expression_parse(const char *string, const char **failed_at, int *error) {
616
+ const char *s;
617
+ int err = EVAL_ERROR_OK;
618
+ unsigned long pos = 0;
619
+
620
+ s = string;
621
+ EVAL_NODE *op = parse_full_expression(&s, &err);
622
+
623
+ if (failed_at) *failed_at = s;
624
+ if (error) *error = err;
625
+
626
+ if(!op) {
627
+ pos = s - string + 1;
628
+ error("failed to parse expression '%s': %s at character %lu (i.e.: '%s').", string, expression_strerror(err), pos, s);
629
+ }
630
+
631
+ return op;
632
+}
633
+
634
+calculated_number expression_evaluate(EVAL_NODE *expression, int *error) {
635
+ int err = EVAL_ERROR_OK;
636
+ calculated_number ret = eval_node(expression, &err);
637
+
638
+ if(err != EVAL_ERROR_OK) {
639
+ error("Failed to execute expression with error %d (%s)", err, expression_strerror(err));
640
+ if(error) *error = err;
641
+ return 0;
642
+ }
643
+
644
+ return ret;
645
+}
646
+
647
+void expression_free(EVAL_NODE *op) {
648
+ if(op) eval_node_free(op);
649
}
650
614
-const char *eval_error(int error) {
651
+const char *expression_strerror(int error) {
652
switch(error) {
653
case EVAL_ERROR_OK:
654
return "success";
@@ -644,39 +681,3 @@ const char *eval_error(int error) {
681
return "unknown error";
682
}
683
}
647
-
648
-EVAL_OPERAND *parse_expression(const char *string, const char **failed_at, int *error) {
649
- const char *s;
650
- int err = EVAL_ERROR_OK;
651
- unsigned long pos = 0;
652
-
653
- s = string;
654
- EVAL_OPERAND *op = parse_operand(&s, &err);
655
-
656
- if (failed_at) *failed_at = s;
657
- if (error) *error = err;
658
-
659
- if(!op) {
660
- pos = s - string + 1;
661
- error("failed to parse expression '%s': %s at character %lu (i.e.: '%s').", string, eval_error(err), pos, s);
662
- }
663
-
664
- return op;
665
-}
666
-
667
-calculated_number evaluate_expression(EVAL_OPERAND *expression, int *error) {
668
- int err = EVAL_ERROR_OK;
669
- calculated_number ret = eval_operand(expression, &err);
670
-
671
- if(err != EVAL_ERROR_OK) {
672
- error("Failed to execute expression with error %d (%s)", err, eval_error(err));
673
- if(error) *error = err;
674
- return 0;
675
- }
676
-
677
- return ret;
678
-}
679
-
680
-void free_expression(EVAL_OPERAND *op) {
681
- if(op) operand_free(op);
682
-}
src/eval.h
+8
-7
@@ -12,7 +12,7 @@ typedef struct variable {
12
#define EVAL_VALUE_VARIABLE 2
13
#define EVAL_VALUE_EXPRESSION 3
14
15
-// these are used for EVAL_OPERAND.operator
15
+// these are used for EVAL_NODE.operator
16
#define EVAL_OPERATOR_NOP '\0'
17
#define EVAL_OPERATOR_VALUE ':'
18
#define EVAL_OPERATOR_EXPRESSION_OPEN '('
@@ -53,21 +53,22 @@ typedef struct eval_value {
53
union {
54
calculated_number number;
55
VARIABLE *variable;
56
- struct eval_operand *expression;
56
+ struct eval_node *expression;
57
};
58
} EVAL_VALUE;
59
60
-typedef struct eval_operand {
60
+typedef struct eval_node {
61
int id;
62
unsigned char operator;
63
int precedence;
64
65
int count;
66
EVAL_VALUE ops[];
67
-} EVAL_OPERAND;
67
+} EVAL_NODE;
68
69
-extern EVAL_OPERAND *parse_expression(const char *string, const char **failed_at, int *error);
70
-extern calculated_number evaluate_expression(EVAL_OPERAND *expression, int *error);
71
-extern void free_expression(EVAL_OPERAND *op);
69
+extern EVAL_NODE *expression_parse(const char *string, const char **failed_at, int *error);
70
+extern calculated_number expression_evaluate(EVAL_NODE *expression, int *error);
71
+extern void expression_free(EVAL_NODE *op);
72
+extern const char *expression_strerror(int error);
73
74
#endif //NETDATA_EVAL_H