laentropia/Calculator
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

refactor: evaluator separated into evaluate bin and un

Browse Source 
Is nicer this way, also made it more beautiful to look at and therefor
to understand.
This commit is contained in:
Alonso Adrian Martinez Hernandez
2026-05-13 18:06:01 -06:00
parent b56a368244
commit 3ec73559ee
3 changed files with 85 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/evaluator.h
View File

@@ -1,7 +1,6 @@
#ifndef EVALUATOR_H
#define EVALUATOR_H
#include "lexer.h"
#include "parser.h"
#include <stdint.h>
@@ -20,6 +19,9 @@ typedef struct {
};
} EvaluatorResult;
EvaluatorResult evaluate_binary(Node *tree);
EvaluatorResult evaluate_unary(Node *tree);
EvaluatorResult evaluate(ParserResult context);
EvaluatorResult evaluate_tree(Node *tree);

1
include/parser.h
View File

@@ -11,7 +11,6 @@ typedef enum {
NODE_INT,
NODE_BINARY_OP,
NODE_UNARY_OP,
NODE_PARENTHESIS,
} NodeType;
typedef struct Node {

152
src/evaluator.c
View File

@@ -9,81 +9,93 @@
EvaluatorResult evaluate_tree(Node *tree) {
if (tree->type == NODE_BINARY_OP) {
Operator op = tree->binary.op;
Node *left = tree->binary.left;
Node *right = tree->binary.right;
switch (op) {
case OP_ADD: {
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val + right_result.val,
};
}
case OP_SUB: {
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val - right_result.val,
};
}
case OP_MUL: {
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val * right_result.val,
};
}
case OP_DIV: {
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val / right_result.val,
};
}
case OP_POW: {
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
return (EvaluatorResult) {
.is_valid = true,
.val = pow(left_result.val, right_result.val),
};
}
default:
return (EvaluatorResult) {
.is_valid = false,
.err = EVALUATOR_INVALID_TREE,
};
}
return evaluate_binary(tree);
} else if (tree->type == NODE_UNARY_OP) {
return evaluate_unary(tree);
}
int64_t return_val = tree->data.integer;
return return_val;
return (EvaluatorResult) {
.is_valid = true,
.val = tree->num,
};
}
EvaluatorResult evaluate(ParseResult context) {
EvaluatorResult evaluate_binary(Node *tree) {
Operator op = tree->binary.op;
Node *left = tree->binary.left;
Node *right = tree->binary.right;
EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid || !right_result.is_valid) {
return left_result;
}
switch (op) {
case OP_ADD:
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val + right_result.val,
};
case OP_SUB:
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val - right_result.val,
};
case OP_MUL:
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val * right_result.val,
};
case OP_DIV:
return (EvaluatorResult) {
.is_valid = true,
.val = left_result.val / right_result.val,
};
case OP_POW:
return (EvaluatorResult) {
.is_valid = true,
.val = pow(left_result.val, right_result.val),
};
default:
return (EvaluatorResult) {
.is_valid = false,
.err = EVALUATOR_INVALID_TREE,
};
}
}
EvaluatorResult evaluate_unary(Node *tree) {
Operator op = tree->unary.op;
Node *to = tree->unary.to;
EvaluatorResult result = evaluate_tree(to);
if (!result.is_valid) {
return result;
}
switch (op) {
case OP_ADD:
return result;
case OP_SUB:
return (EvaluatorResult) {
.is_valid = true,
.val = -result.val,
};
case OP_FACTORIAL:
return (EvaluatorResult) {
.is_valid = true,
.val = tgamma(result.val + 1),
};
default:
return (EvaluatorResult) {
.is_valid = false,
.err = EVALUATOR_INVALID_TREE,
};
}
}
EvaluatorResult evaluate(ParserResult context) {
if (!context.is_valid) {
return (EvaluatorResult) {
.is_valid = false,