Skip to content

Commit a8e1dde

Browse files
coderoddecoderodde
committed
...
1 parent 9492fb8 commit a8e1dde

File tree

5 files changed

+369
-309
lines changed

5 files changed

+369
-309
lines changed

‎src/main/java/io/github/coderodde/simple/stack/machine/CompareInstructionImplementation.java‎

Lines changed: 0 additions & 13 deletions
This file was deleted.

‎src/main/java/io/github/coderodde/simple/stack/machine/InstructionImplementation.java‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
package io.github.coderodde.simple.stack.machine;
2+
3+
public interface InstructionImplementation {
4+
5+
/**
6+
* Executes an operation on the given machine.
7+
*
8+
* @param machine the target machine.
9+
*/
10+
public void execute(final SimpleStackMachine machine);
11+
}

‎src/main/java/io/github/coderodde/simple/stack/machine/MachineLanguageSpecification.java‎

Lines changed: 259 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,259 @@
1+
package io.github.coderodde.simple.stack.machine;
2+
3+
import java.util.function.BinaryOperator;
4+
5+
/**
6+
*
7+
* @version 1.0.0 (Jul 9, 2025)
8+
* @since 1.0.0 (Jul 9, 2025)
9+
*/
10+
public final class MachineLanguageSpecification {
11+
12+
public static final class NopInstructionImplementation
13+
implements InstructionImplementation {
14+
15+
@Override
16+
public void execute(final SimpleStackMachine machine) {
17+
machine.checkReserve(1);
18+
machine.advanceInstructionPointer();
19+
}
20+
}
21+
22+
public static /*final*/ class PushInstructionImplementation
23+
implements InstructionImplementation {
24+
25+
@Override
26+
public void execute(final SimpleStackMachine machine) {
27+
machine.checkReserve(1 + Long.BYTES);
28+
machine.advanceInstructionPointer();
29+
30+
final long number =
31+
machine.readNumberFromTape(machine.getInstructionPointer() );
32+
33+
machine.push(number);
34+
}
35+
}
36+
37+
public static final class PopInstructionImplementation
38+
implements InstructionImplementation {
39+
40+
@Override
41+
public void execute(SimpleStackMachine machine) {
42+
machine.checkReserve(1);
43+
machine.advanceInstructionPointer();
44+
machine.pop();
45+
}
46+
}
47+
48+
public static final class LoadInstructionImplementation
49+
implements InstructionImplementation {
50+
51+
@Override
52+
public void execute(SimpleStackMachine machine) {
53+
machine.checkReserve(1 + Long.BYTES);
54+
machine.advanceInstructionPointer();
55+
56+
final long address =
57+
machine.readNumberFromTape(machine.getInstructionPointer());
58+
59+
final long datum = machine.readNumberFromTape((int) address);
60+
61+
machine.push(datum);
62+
}
63+
}
64+
65+
public static final class StoreInstructionImplementation
66+
implements InstructionImplementation {
67+
68+
@Override
69+
public void execute(SimpleStackMachine machine) {
70+
machine.checkReserve(1 + 2 * Long.BYTES);
71+
machine.advanceInstructionPointer();
72+
73+
final long address =
74+
machine.readNumberFromTape(machine.getInstructionPointer());
75+
76+
machine.advanceInstructionPointer(Long.BYTES);
77+
78+
final long datum = machine.readNumberFromTape(machine.getInstructionPointer());
79+
80+
machine.writeNumberToTape((int) address, datum);
81+
machine.advanceInstructionPointer(Long.BYTES);
82+
}
83+
}
84+
85+
/**
86+
* Delegates to the pop operation.
87+
*/
88+
public static final class ConstInstructionImplementation
89+
extends PushInstructionImplementation {
90+
91+
@Override
92+
public void execute(SimpleStackMachine machine) {
93+
super.execute(machine);
94+
}
95+
}
96+
97+
public static /*final*/ class BinaryArithmeticInstructionImplementation
98+
implements InstructionImplementation {
99+
100+
private final BinaryOperator<Long> func;
101+
102+
public BinaryArithmeticInstructionImplementation(
103+
final BinaryOperator<Long> func) {
104+
this.func = func;
105+
}
106+
107+
@Override
108+
public void execute(SimpleStackMachine machine) {
109+
machine.checkReserve(1 + 2 * Long.BYTES);
110+
machine.requireStackSize(2);
111+
machine.advanceInstructionPointer();
112+
113+
final long number1 =
114+
machine.readNumberFromTape(machine.getInstructionPointer());
115+
116+
final long number2 =
117+
machine.readNumberFromTape(
118+
machine.getInstructionPointer() + Long.BYTES);
119+
120+
machine.pop();
121+
machine.pop();
122+
machine.push(func.apply(number1, number2));
123+
machine.advanceInstructionPointer(Long.BYTES * 2);
124+
}
125+
}
126+
127+
public static final class AddInstructionImplementation
128+
extends BinaryArithmeticInstructionImplementation {
129+
130+
public AddInstructionImplementation() {
131+
super((n1, n2) -> { return n1 + n2; });
132+
}
133+
}
134+
135+
public static final class SubInstructionImplementation
136+
extends BinaryArithmeticInstructionImplementation {
137+
138+
public SubInstructionImplementation() {
139+
super((n1, n2) -> { return n1 - n2; });
140+
}
141+
}
142+
143+
public static final class MultiplyInstructionImplementation
144+
extends BinaryArithmeticInstructionImplementation {
145+
146+
public MultiplyInstructionImplementation() {
147+
super((n1, n2) -> { return n1 * n2; });
148+
}
149+
}
150+
151+
public static final class DivideInstructionImplementation
152+
extends BinaryArithmeticInstructionImplementation {
153+
154+
public DivideInstructionImplementation() {
155+
super((n1, n2) -> { return n1 / n2; });
156+
}
157+
158+
@Override
159+
public void execute(final SimpleStackMachine machine) {
160+
try {
161+
super.execute(machine);
162+
} catch (final ArithmeticException ex) {
163+
throw new StackMachineException(ex.getMessage());
164+
}
165+
}
166+
}
167+
168+
public static final class ModuloInstructionImplementation
169+
extends BinaryArithmeticInstructionImplementation {
170+
171+
public ModuloInstructionImplementation() {
172+
super((n1, n2) -> { return n1 % n2; });
173+
}
174+
175+
@Override
176+
public void execute(final SimpleStackMachine machine) {
177+
try {
178+
super.execute(machine);
179+
} catch (final ArithmeticException ex) {
180+
throw new StackMachineException(ex.getMessage());
181+
}
182+
}
183+
}
184+
185+
public static final class DuplicateInstructionImplementation
186+
implements InstructionImplementation {
187+
188+
@Override
189+
public void execute(final SimpleStackMachine machine) {
190+
machine.checkReserve(1);
191+
machine.requireStackSize(1);
192+
machine.push(machine.top());
193+
machine.advanceInstructionPointer();
194+
}
195+
}
196+
197+
public static final class SwapInstructionImplementation
198+
implements InstructionImplementation {
199+
200+
@Override
201+
public void execute(final SimpleStackMachine machine) {
202+
machine.checkReserve(1);
203+
machine.requireStackSize(2);
204+
final long number1 = machine.pop();
205+
final long number2 = machine.pop();
206+
machine.push(number1);
207+
machine.push(number2);
208+
}
209+
}
210+
211+
public static final class CompareInstructionImplementation
212+
implements InstructionImplementation {
213+
214+
@Override
215+
public void execute(final SimpleStackMachine machine) {
216+
machine.checkReserve(1);
217+
machine.requireStackSize(2);
218+
final long number1 = machine.pop();
219+
final long number2 = machine.pop();
220+
final int cmp = Long.compare(number1,
221+
number2);
222+
223+
if (cmp < 0) {
224+
machine.flags().belowFlag = true;
225+
} else if (cmp > 0) {
226+
machine.flags().aboveFlag = true;
227+
} else {
228+
machine.flags().equalFlag = true;
229+
}
230+
}
231+
}
232+
233+
public static final class UnconditionalJumpInstructionImplementation
234+
implements InstructionImplementation {
235+
236+
@Override
237+
public void execute(final SimpleStackMachine machine) {
238+
machine.checkReserve(1 + Long.BYTES);
239+
machine.advanceInstructionPointer();
240+
final int jumpAddress =
241+
(int) machine.readNumberFromTape(
242+
machine.getInstructionPointer());
243+
244+
machine.checkReserve(jumpAddress);
245+
machine.setInstructionPointer(jumpAddress);
246+
}
247+
}
248+
249+
public static final class HaltInstructionImplementation
250+
implements InstructionImplementation {
251+
252+
@Override
253+
public void execute(final SimpleStackMachine machine) {
254+
machine.checkReserve(1);
255+
machine.requestHalt();
256+
}
257+
}
258+
259+
}

‎src/main/java/io/github/coderodde/simple/stack/machine/Operation.java‎

Lines changed: 16 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,21 @@
11
package io.github.coderodde.simple.stack.machine;
22

3-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.AddInstructionImplementation;
4-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.CompareInstructionImplementation;
5-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.ConstInstructionImplementation;
6-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.DivideInstructionImplementation;
7-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.DuplicateInstructionImplementation;
8-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.HaltInstructionImplementation;
9-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.InstructionImplementation;
10-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.LoadInstructionImplementation;
11-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.ModuloInstructionImplementation;
12-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.MultiplyInstructionImplementation;
13-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.NopInstructionImplementation;
14-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.PopInstructionImplementation;
15-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.PushInstructionImplementation;
16-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.StoreInstructionImplementation;
17-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.SubInstructionImplementation;
18-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.SwapInstructionImplementation;
19-
import io.github.coderodde.simple.stack.machine.SimpleStackMachine.UnconditionalJumpInstructionImplementation;
3+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.AddInstructionImplementation;
4+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.CompareInstructionImplementation;
5+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.ConstInstructionImplementation;
6+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.DivideInstructionImplementation;
7+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.DuplicateInstructionImplementation;
8+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.HaltInstructionImplementation;
9+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.LoadInstructionImplementation;
10+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.ModuloInstructionImplementation;
11+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.MultiplyInstructionImplementation;
12+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.NopInstructionImplementation;
13+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.PopInstructionImplementation;
14+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.PushInstructionImplementation;
15+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.StoreInstructionImplementation;
16+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.SubInstructionImplementation;
17+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.SwapInstructionImplementation;
18+
import io.github.coderodde.simple.stack.machine.MachineLanguageSpecification.UnconditionalJumpInstructionImplementation;
2019
import java.util.HashMap;
2120
import java.util.Map;
2221

0 commit comments

Comments
 (0)