rad-py/expression.cpp at master · radiilab/rad-py · 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
#include "symbolTable.h"
#include "function.h"
#include "functionTable.h"
#include "expression.h"

Number Constant::eval(const SymbolTable &st, const FunctionTable &ft) const {
   return num;
}

Number Identifier::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return st[name];
}

Negation::~Negation() {
   delete op;
}

Number Negation::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return -(op->eval(st, ft));
}

FunctionCallExp::~FunctionCallExp() {
   delete argList;
}

Number FunctionCallExp::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return ft[name]->apply(st, ft, argList);
}

BinaryExpression::~BinaryExpression() {
   delete op1;
   delete op2;
}

Number Addition::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) + op2->eval(st, ft);
}

Number Subtraction::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) - op2->eval(st, ft);
}

Number Multiplication::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) * op2->eval(st, ft);
}

Number Division::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) / op2->eval(st, ft);
}

Number Modulus::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) % op2->eval(st, ft);
}

Number Exponent::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) ^ op2->eval(st, ft);
}

Number LessThan::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) < op2->eval(st, ft);
}

Number GreaterThan::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) > op2->eval(st, ft);
}

Number LessThanOrEqualTo::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) <= op2->eval(st, ft);
}

Number GreaterThanOrEqualTo::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) >= op2->eval(st, ft);
}

Number Equals::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) == op2->eval(st, ft);
}

Number NotEquals::eval(const SymbolTable& st, const FunctionTable& ft) const {
   return op1->eval(st, ft) != op2->eval(st, ft);
}

void ExpressionList::add(Expression* exp) {
   expList.push_back(exp);
}

unsigned int ExpressionList::size() const {
   return expList.size();
}

list<Expression*>::const_iterator ExpressionList::begin() const {
   return expList.begin();
}

list<Expression*>::const_iterator ExpressionList::end() const {
   return expList.end();
}

ExpressionList::~ExpressionList() {
   for (list<Expression*>::iterator it = expList.begin(); it != expList.end(); ++it) {
      delete *it;
   }
}