Programming-Language-Translation/code_generator/evaluator.cpp at main · IvanDzanija/Programming-Language-Translation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <stack>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>

// Operator precedence and associativity
struct Operator {
	int precedence;
	bool rightAssociative;
};

const std::unordered_map<std::string, Operator> OPERATORS = {
	{"PLUS", {1, false}},		{"MINUS", {1, false}},
	{"OP_PUTA", {2, false}},	{"OP_DIJELI", {2, false}},
	{"OP_MOD", {2, false}},		{"OP_BIN_I", {4, false}},
	{"OP_BIN_ILI", {4, false}}, {"OP_BIN_XILI", {4, false}},
	{"OP_TILDA", {6, true}},	{"OP_NEG", {6, true}}};

bool isOperator(const std::string &token) {
	return OPERATORS.find(token) != OPERATORS.end();
}

bool isUnary(const std::string &token) {
	return token == "OP_TILDA" || token == "OP_NEG";
}

int evaluate(const std::vector<std::string> &expr) {
	std::vector<std::string> output;
	std::stack<std::string> opStack;

	for (size_t i = 0; i < expr.size(); ++i) {
		const std::string &token = expr[i];

		try {
			int number = std::stoi(token);
			output.push_back(token);
		} catch (std::invalid_argument arg) {
			if (isOperator(token)) { // Operator
				while (!opStack.empty() && isOperator(opStack.top())) {
					const std::string &topOp = opStack.top();
					if ((OPERATORS.at(token).rightAssociative &&
						 OPERATORS.at(token).precedence <
							 OPERATORS.at(topOp).precedence) ||
						(!OPERATORS.at(token).rightAssociative &&
						 OPERATORS.at(token).precedence <=
							 OPERATORS.at(topOp).precedence)) {
						output.push_back(opStack.top());
						opStack.pop();
					} else {
						break;
					}
				}
				opStack.push(token);
			} else if (token == "(") {
				opStack.push(token);
			} else if (token == ")") {
				while (!opStack.empty() && opStack.top() != "(") {
					output.push_back(opStack.top());
					opStack.pop();
				}
				if (!opStack.empty() && opStack.top() == "(") {
					opStack.pop();
				}
			}
		}
	}

	while (!opStack.empty()) {
		output.push_back(opStack.top());
		opStack.pop();
	}

	std::stack<int> values;

	for (const std::string &token : output) {
		try { // Operand
			values.push(std::stoi(token));
		} catch (std::invalid_argument arg) {
			if (isOperator(token)) { // Operator
				if (isUnary(token)) {
					if (values.empty())
						return 0;
					int val = values.top();
					values.pop();
					if (token == "OP_TILDA")
						values.push(~val);
					else if (token == "OP_NEG")
						values.push(!val);
				} else {
					if (values.size() < 2)
						return 0;
					int b = values.top();
					values.pop();
					int a = values.top();
					values.pop();

					if (token == "PLUS")
						values.push(a + b);
					else if (token == "MINUS")
						values.push(a - b);
					else if (token == "OP_PUTA")
						values.push(a * b);
					else if (token == "OP_DIJELI")
						values.push(a / b);
					else if (token == "OP_MOD")
						values.push(a % b);
					else if (token == "OP_BIN_XILI")
						values.push(a ^ b);
					else if (token == "OP_BIN_I")
						values.push(a & b);
					else if (token == "OP_BIN_ILI")
						values.push(a | b);
				}
			}
		}
	}

	if (values.size() != 1)
		return 0;
	return values.top();
}