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
|
package org.zwobble.couscous.interpreter.values;
import java.util.Optional;
import java.util.function.BiFunction;
import org.zwobble.couscous.ast.Operator;
import org.zwobble.couscous.interpreter.*;
import org.zwobble.couscous.values.IntegerValue;
import org.zwobble.couscous.values.ObjectValues;
import org.zwobble.couscous.values.PrimitiveValue;
import org.zwobble.couscous.values.PrimitiveValues;
import static org.zwobble.couscous.util.ExtraLists.list;
public final class IntegerInterpreterValue implements InterpreterValue {
public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF)
.method(Operator.ADD.getMethodName(), list(IntegerValue.REF),
infixReturningInteger((left, right) -> left + right))
.method(Operator.SUBTRACT.getMethodName(), list(IntegerValue.REF),
infixReturningInteger((left, right) -> left - right))
.method(Operator.MULTIPLY.getMethodName(), list(IntegerValue.REF),
infixReturningInteger((left, right) -> left * right))
.method(Operator.DIVIDE.getMethodName(), list(IntegerValue.REF),
infixReturningInteger((left, right) -> left / right))
.method(Operator.MOD.getMethodName(), list(IntegerValue.REF),
infixReturningInteger((left, right) -> left % right))
.method(Operator.EQUALS.getMethodName(), list(ObjectValues.OBJECT),
(environment, arguments) -> {
InterpreterValue right = arguments.getPositionalArguments().get(0);
if (right instanceof IntegerInterpreterValue) {
return integerEquals(arguments, ((IntegerInterpreterValue)right));
} else {
return BooleanInterpreterValue.of(false);
}
})
.method(Operator.EQUALS.getMethodName(), list(IntegerValue.REF),
(environment, arguments) -> {
IntegerInterpreterValue right = (IntegerInterpreterValue)arguments.getPositionalArguments().get(0);
return integerEquals(arguments, right);
})
.method(Operator.NOT_EQUALS.getMethodName(), list(IntegerValue.REF),
infixReturningBoolean((left, right) -> !left.equals(right)))
.method(Operator.GREATER_THAN.getMethodName(), list(IntegerValue.REF),
infixReturningBoolean((left, right) -> left > right))
.method(Operator.GREATER_THAN_OR_EQUAL.getMethodName(), list(IntegerValue.REF),
infixReturningBoolean((left, right) -> left >= right))
.method(Operator.LESS_THAN.getMethodName(), list(IntegerValue.REF),
infixReturningBoolean((left, right) -> left < right))
.method(Operator.LESS_THAN_OR_EQUAL.getMethodName(), list(IntegerValue.REF),
infixReturningBoolean((left, right) -> left <= right))
.build();
private static BooleanInterpreterValue integerEquals(MethodCallArguments<IntegerInterpreterValue> arguments, IntegerInterpreterValue right) {
return BooleanInterpreterValue.of(arguments.getReceiver().getValue() == right.getValue());
}
private static
BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue>
infixReturningInteger(BiFunction<Integer, Integer, Integer> func) {
return infix((left, right) -> new IntegerInterpreterValue(func.apply(left, right)));
}
private static
BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue>
infixReturningBoolean(BiFunction<Integer, Integer, Boolean> func) {
return infix((left, right) -> BooleanInterpreterValue.of(func.apply(left, right)));
}
private static
BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue>
infix(BiFunction<Integer, Integer, InterpreterValue> func) {
return (environment, arguments) -> {
IntegerInterpreterValue left = arguments.getReceiver();
IntegerInterpreterValue right = (IntegerInterpreterValue) arguments.get(0);
return func.apply(left.getValue(), right.getValue());
};
}
private final int value;
@Override
public ConcreteType getType() {
return TYPE;
}
@Override
public Optional<PrimitiveValue> toPrimitiveValue() {
return Optional.of(PrimitiveValues.value(value));
}
@Override
public InterpreterValue getField(String fieldName) {
throw new NoSuchField(fieldName);
}
@Override
public void setField(String fieldName, InterpreterValue value) {
throw new NoSuchField(fieldName);
}
public IntegerInterpreterValue(final int value) {
this.value = value;
}
public int getValue() {
return this.value;
}
@java.lang.Override
public boolean equals(final java.lang.Object o) {
if (o == this) return true;
if (!(o instanceof IntegerInterpreterValue)) return false;
final IntegerInterpreterValue other = (IntegerInterpreterValue)o;
if (this.getValue() != other.getValue()) return false;
return true;
}
@java.lang.Override
public int hashCode() {
final int PRIME = 59;
int result = 1;
result = result * PRIME + this.getValue();
return result;
}
@java.lang.Override
public java.lang.String toString() {
return "IntegerInterpreterValue(value=" + this.getValue() + ")";
}
}
|
