blob: c71874b3c682c92a2402e9e3cab5c37ca22bab9f (
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
package Compiler;
import java.util.List;
//Class for possible expressions in the language
abstract class Expression {
/**
* Class for representing a binary expression, with two values between an operator
*/
static class Binary extends Expression{
final Expression left;
final Expression right;
final Token op;
Binary(Expression left, Token op, Expression right){
this.left=left;
this.op=op;
this.right = right;
}
@Override
public String getExpressionType() {
return "binary";
}
}
/**
* Class for representing a singlular expression, with one value and one operator
*/
static class Singular extends Expression{
final Expression right;
final Token op;
Singular(Token op, Expression right){
this.op=op;
this.right = right;
}
@Override
public String getExpressionType() {
return "singular";
}
}
/**
* Class for representing a literal value
*/
static class Literal extends Expression{
final Token value;
final String type;
Literal(Token value,String type){
this.value=value;
this.type=type;
}
@Override
public String getExpressionType() {
return "literal";
}
}
/**
* Class for representing an expression between brackets
*/
static class BracketedExpression extends Expression{
final Expression expr;
BracketedExpression(Expression expr){
this.expr=expr;
}
@Override
public String getExpressionType() {
return "bracket";
}
}
/**
* Class for represening an assignment expression
*/
static class AssignmentExpression extends Expression{
final Expression variable;
final Expression value;
AssignmentExpression(Expression variable,Expression value){
this.variable=variable;
this.value=value;
}
@Override
public String getExpressionType() {
return "assign";
}
}
/**
* Class for representing a single variable
*/
static class Variable extends Expression{
Variable(Token name){
this.name=name;
}
@Override
public String getExpressionType() {
return "var";
}
final Token name;
}
/**
* Class for representing an array variable
*/
static class ArrayVariable extends Expression{
ArrayVariable(Token name,List<Expression> positions){
this.name=name;
this.positions=positions;
}
@Override
public String getExpressionType() {
return "arrayvar";
}
final Token name;
final List<Expression> positions;
}
/**
* Class for representing a function call
*/
static class FunctionCall extends Expression{
FunctionCall(Token name, List<Expression> arguments){
this.arguments=arguments;
this.name=name;
}
final List<Expression> arguments;
final Token name;
@Override
public String getExpressionType() {
return "functCall";
}
}
//Abstract method for getting an expression type
public abstract String getExpressionType();
}
|
