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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/* PIA - Lenguajes Modernos de Programación
* FACULTAD DE CIENCIAS FÍSICO MATEMÁTICAS
* Luis Sebastián Martínez Vega - LCC */
#ifndef EXPRESSIONS_H
#define EXPRESSIONS_H
#include <string>
#include "lexer.hpp"
/* Debido a que en eval() llamamos a la respectiva
función trigonométrica, hay un conflicto entre
nombres de las funciones definidas en cmath y
los nombres definidos aquí. Por esa razón decidí
renombrarlos con el prefijo i_ que significa
"identifier". Esto puede ser solucionado con un
namespace, pero es mucho pedo, así lo dejo.*/
enum trig_functions {
i_sin,
i_cos,
i_tan,
i_csc,
i_sec,
i_ctg
};
class Differentiator; // Forward declaration.
class Expression {
public:
Expression(Expression *left, Expression *right, token_type type);
virtual ~Expression() = default;
std::string getRepr();
Expression *diff(const Differentiator *d);
Expression *getLeft();
Expression *getRight();
virtual float eval(int arg) = 0;
virtual Expression *copy() = 0; // Regresa una copia de la expresión actual.
protected:
Expression *left;
Expression *right;
token_type type;
virtual void setRepr();
void delTree();
std::string repr{};
};
class Literal : public Expression {
private:
int value;
public:
explicit Literal(int value);
~Literal();
int getValue();
float eval(int arg) override;
Expression *copy() override;
protected:
void setRepr() override;
};
class Function : public Expression {
private:
trig_functions function_name;
Expression *arg;
public:
Function(Expression *arg, trig_functions name);
~Function();
Expression *getArg();
float eval(int arg) override;
trig_functions getFunctionName() const;
Expression *copy() override;
protected:
void delTree();
void setRepr() override;
};
class Variable : public Expression {
private:
char name;
public:
explicit Variable(char name);
~Variable();
float eval(int arg) override;
Expression *copy() override;
protected:
void setRepr() override;
};
class AddExpression : public Expression {
public:
AddExpression(Expression *left, Expression *right);
~AddExpression();
float eval(int arg) override;
Expression *copy() override;
};
class SubExpression : public Expression {
public:
SubExpression(Expression *left, Expression *right);
~SubExpression();
float eval(int arg) override;
Expression *copy() override;
};
class NegationExpression : public Expression {
public:
explicit NegationExpression(Expression *right);
~NegationExpression();
float eval(int arg) override;
Expression *copy() override;
protected:
void setRepr() override;
};
class DivisionExpression : public Expression {
public:
DivisionExpression(Expression *left, Expression *right);
~DivisionExpression();
float eval(int arg) override;
Expression *copy() override;
};
class MultiplicationExpression : public Expression {
public:
MultiplicationExpression(Expression *left, Expression *right);
~MultiplicationExpression();
float eval(int arg) override;
Expression *copy() override;
};
class PowerExpression : public Expression {
public:
PowerExpression(Expression *left, Expression *right);
~PowerExpression();
float eval(int arg) override;
Expression *copy() override;
};
#endif /* EXPRESSIONS_H */
|
