fix operand resolution to match specmain

1 files changed, 508 insertions, 0 deletions

diff --git a/src/vm/instruction.test.js.n b/src/vm/instruction.test.js.n
new file mode 100644
index 0000000..cf23404
--- /dev/null
+++ b/src/vm/instruction.test.js.n
@@ -0,0 +1,508 @@
+'use strict';
+
+const { Core } = require('./core.js');
+const { 
+	DAT, 
+	MOV, ADD, SUB, CMP, SLT,
+	JMP, JMZ, JMN, DJN, SPL,
+} = require('./instruction.js');
+
+
+const CORESIZE = 8000;
+
+
+test('DAT does nothing and kills the program', () => {
+	const core = new Core(CORESIZE);
+	const pc = 0;
+	const ins = core.data[pc];
+	expect(DAT(core, pc, ins)).toEqual([]);
+});
+
+
+test('MOV correctly moves a full instruction', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'MOV',
+		a: { mode: 'direct', value: 0 },
+		b: { mode: 'direct', value: 1 },
+	};
+	const ins = core.data[pc];
+	expect(core.data[pc+1].opcode).toBe('DAT');
+	expect(MOV(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc]).toEqual(core.data[pc+1]);
+	expect(core.data[pc+1].opcode).toBe('MOV');
+});
+
+
+test('MOV correctly moves a B-field', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'MOV',
+		a: { mode: 'immediate', value: 100 },
+		b: { mode: 'direct', value: 1 },
+	};
+	const ins = core.data[pc];
+	expect(core.data[pc+1].opcode).toBe('DAT');
+	expect(MOV(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 100 },
+	});
+});
+
+
+test('MOV correctly handles indirection', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc-1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 2 },
+	};
+	core.data[pc] = {
+		opcode: 'MOV',
+		a: { mode: 'immediate', value: 100 },
+		b: { mode: 'indirect', value: -1 },
+	};
+	const ins = core.data[pc];
+	expect(core.data[pc+1].opcode).toBe('DAT');
+	expect(MOV(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc-1]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 2 },
+	});
+
+	expect(core.data[pc+2]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 100 },
+	});
+
+});
+
+
+
+
+test('MOV correctly handles predecrement indirection', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'MOV',
+		a: { mode: 'immediate', value: 100 },
+		b: { mode: 'predecrement', value: 1 },
+	};
+	const ins = core.data[pc];
+	expect(core.data[pc+1].opcode).toBe('DAT');
+	expect(MOV(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: -1 },
+	});
+
+	expect(core.data[pc-1]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 100 },
+	});
+
+});
+
+
+test('MOV correctly handles core boundaries', () => {
+	const core = new Core(CORESIZE);
+	const pc = CORESIZE-1;
+	core.data[pc] = {
+		opcode: 'MOV',
+		a: { mode: 'immediate', value: 100 },
+		b: { mode: 'predecrement', value: 2 },
+	};
+	const ins = core.data[pc];
+	expect(core.data[0].opcode).toBe('DAT');
+	expect(MOV(core, pc, ins)).toEqual([0]);
+	expect(core.data[1]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: -1 },
+	});
+
+	expect(core.data[CORESIZE-2]).toEqual({	
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 0 },
+		b: { mode: 'immediate', value: 100 },
+	});
+
+});
+
+
+
+test('ADD correctly adds two full instructions', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'ADD',
+		a: { mode: 'direct', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(ADD(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	});
+	expect(core.data[pc+2]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 13 },
+		b: { mode: 'immediate', value: 24 },
+	});
+});
+
+
+test('ADD correctly adds B-field', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'ADD',
+		a: { mode: 'immediate', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(ADD(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	});
+	expect(core.data[pc+2]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 5 },
+	});
+});
+
+
+test('SUB correctly subtracts two full instructions', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'SUB',
+		a: { mode: 'direct', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(SUB(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	});
+	expect(core.data[pc+2]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: -7 },
+		b: { mode: 'immediate', value: -16 },
+	});
+});
+
+
+test('SUB correctly subtracts B-field', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'SUB',
+		a: { mode: 'immediate', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(SUB(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	});
+	expect(core.data[pc+2]).toEqual({
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 3 },
+	});
+});
+
+
+test('CMP properly compares full instructions', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'CMP',
+		a: { mode: 'direct', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 10 },
+		b: { mode: 'immediate', value: 20 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(CMP(core, pc, ins)).toEqual([pc+1]);
+
+	core.data[pc+2] = JSON.parse(JSON.stringify(core.data[pc+1]));
+	
+	expect(CMP(core, pc, ins)).toEqual([pc+2]);
+});
+
+
+test('CMP properly compares B-field', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'CMP',
+		a: { mode: 'immediate', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(CMP(core, pc, ins)).toEqual([pc+1]);
+
+	core.data[pc+2].b.value = 1;
+	
+	expect(CMP(core, pc, ins)).toEqual([pc+2]);
+});
+
+
+test('SLT properly compares full instructions', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'SLT',
+		a: { mode: 'direct', value: 1 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(SLT(core, pc, ins)).toEqual([pc+1]);
+
+	core.data[pc+2].b.value = 5;
+	
+	expect(SLT(core, pc, ins)).toEqual([pc+2]);
+});
+
+
+
+test('SLT properly compares B-fields', () => {
+	const core = new Core(CORESIZE);
+	const pc = 20;
+	core.data[pc] = {
+		opcode: 'SLT',
+		a: { mode: 'immediate', value: 7 },
+		b: { mode: 'direct', value: 2 },
+	};
+	core.data[pc+2] = {
+		opcode: 'DAT',
+		a: { mode: 'immediate', value: 3 },
+		b: { mode: 'immediate', value: 4 },
+	};
+	const ins = core.data[pc];
+
+	expect(SLT(core, pc, ins)).toEqual([pc+1]);
+
+	core.data[pc+2].b.value = 8;
+	
+	expect(SLT(core, pc, ins)).toEqual([pc+2]);
+});
+
+
+test('JMP correctly jumps', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'JMP',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 0 },
+	};
+	const ins = core.data[pc];
+
+	expect(JMP(core, pc, ins)).toEqual([CORESIZE-1]);
+});
+
+
+test('JMZ correctly jumps in non-immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'JMZ',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 1 },
+	};
+	core.data[pc+1] = {
+		opcode: 'JMZ',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 1 },
+	};
+	const ins = core.data[pc];
+
+	expect(JMZ(core, pc, ins)).toEqual([pc+1]);
+	core.data[pc+1].b.value = 0;
+	expect(JMZ(core, pc, ins)).toEqual([CORESIZE-1]);
+});
+
+
+test('JMZ correctly jumps in immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'JMZ',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'immediate', value: 1 },
+	};
+	const ins = core.data[pc];
+
+	expect(JMZ(core, pc, ins)).toEqual([pc+1]);
+	core.data[pc].b.value = 0;
+	expect(JMZ(core, pc, ins)).toEqual([CORESIZE-1]);
+});
+
+
+test('JMN correctly jumps in non-immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'JMN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 1 },
+	};
+	core.data[pc+1] = {
+		opcode: 'JMN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 0 },
+	};
+	const ins = core.data[pc];
+
+	expect(JMN(core, pc, ins)).toEqual([pc+1]);
+	core.data[pc+1].b.value = 1;
+	expect(JMN(core, pc, ins)).toEqual([CORESIZE-1]);
+});
+
+
+test('JMN correctly jumps in immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'JMN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'immediate', value: 0 },
+	};
+	const ins = core.data[pc];
+
+	expect(JMN(core, pc, ins)).toEqual([pc+1]);
+	core.data[pc].b.value = 1;
+	expect(JMN(core, pc, ins)).toEqual([CORESIZE-1]);
+});
+
+
+test('DJN correctly jumps in non-immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'DJN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 1 },
+	};
+	core.data[pc+1] = {
+		opcode: 'DJN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'direct', value: 1 },
+	};
+	const ins = core.data[pc];
+
+	expect(DJN(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc+1].b.value).toBe(0);
+	expect(DJN(core, pc, ins)).toEqual([CORESIZE-1]);
+	expect(core.data[pc+1].b.value).toBe(-1);
+});
+
+
+test('DJN correctly jumps in immediate mode', () => {
+	const core = new Core(CORESIZE);
+	const pc = 2;
+	core.data[pc] = {
+		opcode: 'DJN',
+		a: { mode: 'direct', value: -3 },
+		b: { mode: 'immediate', value: 1 },
+	};
+	const ins = core.data[pc];
+
+	expect(DJN(core, pc, ins)).toEqual([pc+1]);
+	expect(core.data[pc].b.value).toBe(0);
+	expect(DJN(core, pc, ins)).toEqual([CORESIZE-1]);
+	expect(core.data[pc].b.value).toBe(-1);
+});
+
+