Added a stack, push and pop. Only instructions. Not wired to machine yet

Author: craftybones

.gitignore

@@ -1,3 +1,5 @@
+out/
+.vscode
 .nyc_output/
 node_modules/
 .DS_Store

src/commands/pop.js

@@ -0,0 +1,29 @@
+/**
+ * The Pop command pops the stack and puts the popped value into the given register at execution time.
+ */
+class Pop {
+ /**
+ * Keeps note of the register to pop into from the stack
+ * @param {string} reg - The register to push into
+ */
+ constructor(reg) {
+ this.reg = reg;
+ }
+
+ /**
+ * Execute will pop the top of the stack and stores the value in the register specified.
+ * @param {Object} currRegs - The current state of the registers
+ * @param {Object} currFlags - The current state of the flags
+ * @param {Object} stack - The stack
+ * @returns {Object} current registers and current flags are returned unchanged with the popped value in the specified register
+ */
+ execute(currRegs, currFlags, stack) {
+ let {A,B,C,D} = currRegs;
+ let newRegs = {A,B,C,D};
+ let value = stack.pop();
+ newRegs[this.reg] = value;
+ return { regs: newRegs, flags: currFlags };
+ }
+}
+
+module.exports = Pop;

src/commands/push.js

@@ -0,0 +1,27 @@
+/**
+ * The Push command pushes a given register on to the stack at execution time.
+ */
+class Push {
+ /**
+ * Keeps note of the register to push onto stack
+ * @param {string} reg - The register to push onto the stack
+ */
+ constructor(reg) {
+ this.reg = reg;
+ }
+
+ /**
+ * Execute will push the value of the register specified in the constructor onto the stack.
+ * @param {Object} currRegs - The current state of the registers
+ * @param {Object} currFlags - The current state of the flags
+ * @param {Object} stack - The stack
+ * @returns {Object} current registers and current flags are returned unchanged
+ */
+ execute(currRegs, currFlags, stack) {
+ let value = currRegs[this.reg];
+ stack.push(value);
+ return { regs: currRegs, flags: currFlags };
+ }
+}
+
+module.exports = Push;

src/stack.js

@@ -0,0 +1,37 @@
+/**
+ * A simple Stack representation that Machine will use to keep track of a call stack
+ */
+class Stack {
+ /**
+ * Initialises a stack
+ */
+ constructor() {
+ this.stack = [];
+ }
+
+ /**
+ * Pushes the given value onto the stack
+ * @param {number} value - The value to be pushed onto a stack.
+ */
+ push(value) {
+ this.stack.push(value);
+ }
+
+ /**
+ * Pops the topmost value from the stack
+ * @returns {number}
+ */
+ pop() {
+ return this.stack.pop();
+ }
+
+ /**
+ * Returns an array representation of the stack
+ * @returns {number[]} The stack represented as an array with the last number pushed at the tail of the array and the first number pushed at the head of the array.
+ */
+ asArray() {
+ return this.stack.map(a => a);
+ }
+}
+
+module.exports = Stack;

test/testPop.js

@@ -0,0 +1,39 @@
+const assert = require('assert');
+const Pop = require('../src/commands/pop.js');
+const Stack = require('../src/stack.js');
+
+describe('Pop execution', () => {
+ it('should pop from the stack to the A register', () => {
+ let pop = new Pop('A');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 0, B: 0, C: 0, D: 0 };
+ let stack = new Stack();
+ stack.push(10)
+ let {regs} = pop.execute(currRegs, currFlags, stack);
+ assert.deepEqual([], stack.asArray());
+ assert.deepEqual({ A: 10, B: 0, C: 0, D: 0 },regs);
+ });
+
+ it('should pop from the stack to the B register', () => {
+ let pop = new Pop('B');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 0, B: 0, C: 0, D: 0 };
+ let stack = new Stack();
+ stack.push(10)
+ let {regs} = pop.execute(currRegs, currFlags, stack);
+ assert.deepEqual([], stack.asArray());
+ assert.deepEqual({ A: 0, B: 10, C: 0, D: 0 },regs);
+ });
+
+ it('should not modify the current flags', () => {
+ let pop = new Pop('A');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 0, B: 0, C: 0, D: 0 };
+ let stack = new Stack();
+ stack.push(10)
+ let {regs,flags} = pop.execute(currRegs, currFlags, stack);
+ assert.deepEqual([], stack.asArray());
+ assert.deepEqual({ A: 10, B: 0, C: 0, D: 0 },regs);
+ assert.deepEqual({ EQ: 0, NE: 0, LT: 0, GT: 0 },flags);
+ });
+});

test/testPush.js

@@ -0,0 +1,33 @@
+const assert = require('assert');
+const Push = require('../src/commands/push.js');
+const Stack = require('../src/stack.js');
+
+describe('Push execution', () => {
+ it('should push the A register to stack', () => {
+ let push = new Push('A');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 10, B: 0, C: 0, D: 0 };
+ let stack = new Stack();
+ push.execute(currRegs, currFlags, stack);
+ assert.deepEqual([10], stack.asArray());
+ });
+
+ it('should push the B register to stack', () => {
+ let push = new Push('B');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 0, B: 10, C: 0, D: 0 };
+ let stack = new Stack();
+ push.execute(currRegs, currFlags, stack);
+ assert.deepEqual([10], stack.asArray());
+ });
+
+ it('should not modify the current registers or flags', () => {
+ let push = new Push('A');
+ let currFlags = { EQ: 0, NE: 0, LT: 0, GT: 0 };
+ let currRegs = { A: 10, B: 0, C: 0, D: 0 };
+ let stack = new Stack();
+ let { regs, flags } = push.execute(currRegs, currFlags, stack);
+ assert.deepEqual({ EQ: 0, NE: 0, LT: 0, GT: 0 }, flags);
+ assert.deepEqual({ A: 10, B: 0, C: 0, D: 0 }, regs);
+ });
+});

test/testStack.js

@@ -0,0 +1,32 @@
+const assert = require('assert');
+const Stack = require('../src/stack.js');
+
+describe('Stack ', () => {
+ it('should be able to push a value on to a stack', () => {
+ let stack = new Stack();
+ stack.push(5);
+ assert.deepEqual([5], stack.asArray());
+ });
+
+ it('should be able to push more than one value on to a stack', () => {
+ let stack = new Stack();
+ stack.push(5);
+ stack.push(6);
+ assert.deepEqual([5, 6], stack.asArray());
+ });
+
+ it('should be able to pop a value from the stack', () => {
+ let stack = new Stack();
+ stack.push(5);
+ assert.equal(5, stack.pop());
+ assert.deepEqual([], stack.asArray());
+ });
+
+ it('should only pop the topmost value from the stack', () => {
+ let stack = new Stack();
+ stack.push(5);
+ stack.push(6);
+ assert.equal(6, stack.pop());
+ assert.deepEqual([5], stack.asArray());
+ });
+});