blob: 65cdeb42b923d38bc74f77281588b1d4e6fae69c (
plain)
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
|
package Interpreter;
import java.util.List;
import Interpreter.Expression.*;
import Interpreter.Statement.ExpressionStatement;
import Interpreter.Statement.PrintStatement;
import Interpreter.Statement.VariableDeclaration;
public class Interpreter {
private Environment environment = new Environment();
void interpret(List<Statement> statements){
try{
for (Statement statement: statements){
evaluateStatement(statement);
}
} catch (Error e){
}
}
private Object evaluateStatement(Statement statement){
switch(statement.getStatmentType()){
case "exprStmt":
return evalExpressionStatement((ExpressionStatement)statement);
case "vardec":
return evalVariableDeclaration((VariableDeclaration)statement);
case "print":
return evalPrintStatement((PrintStatement)statement);
default:
return null;
}
}
private Object evalExpressionStatement(ExpressionStatement stmt){
return evaluateExpression(stmt.expr);
}
private Object evalVariableDeclaration(VariableDeclaration vardec){
environment.defineVariable(vardec.name.text, null);
return null;
}
private Object evalPrintStatement(PrintStatement print){
System.out.println(evaluateExpression(print.expr));
return null;
}
private Object evaluateExpression(Expression expression){
switch(expression.getExpressionType()){
case "binary":
return evaluateBinaryExpression((Binary)expression);
case "literal":
return evaluateLiteralExpression((Literal)expression);
case "bracket":
return evaluateBracketedExpression((BracketedExpression)expression);
case "assign":
return evaluateAssignmentExpression((AssignmentExpression)expression);
case "var":
return evaluateVariableExpression((Variable)expression);
default:
return null;
}
}
private Object evaluateBinaryExpression(Binary expr){
Object leftEval = evaluateExpression(expr.left);
Object rightEval = evaluateExpression(expr.right);
switch (expr.op.type){
case PLUS:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval + (double)rightEval;
}
case STAR:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval * (double)rightEval;
}
case MINUS:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval - (double)rightEval;
}
case SLASH:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval / (double)rightEval;
}
case GREATER:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval > (double)rightEval;
}
case LESS:
if (checkOperandsNum(leftEval, leftEval)){
return (double)leftEval < (double)rightEval;
}
case EQUALITY:
return leftEval.equals(rightEval);
default:
break;
}
return null;
}
private Object evaluateLiteralExpression(Literal expr){
return expr.value.value;
}
private Object evaluateBracketedExpression(BracketedExpression expr){
return evaluateExpression(expr.expr);
}
private Object evaluateAssignmentExpression(AssignmentExpression expr){
Object assignedValue = evaluateExpression(expr.value);
environment.assignVariable(expr.name.text, assignedValue);
return null;
}
private Object evaluateVariableExpression(Variable expr){
return environment.getVariable(expr.name.text);
}
private boolean checkOperandsNum(Object left, Object right){
if (left instanceof Double && right instanceof Double){
return true;
} else {
Language.displayError("Operands must be numbers");
throw new Error();
}
}
}
|
