The purpose of this homework is to get you familiarized with the following concepts:

1. basic TypeScript development
2. use of data structures in TypeScript
3. use of command line parameters
4. reading data from files
5. basic string splitting and processing
6. the way a simple CPU works

The purpose of the homework is to simulate a CPU. This is a very simple CPU, it has one register, called R, and an infinite stack space, called STACK. The CPU performs all computation using signed integer numbers. It does not know how to handle floating point numbers.

The instruction set is divided into three instructions categories:

1. No Action - these instructions do not perform any action
2. Memory - these instructions allow the CPU to interact with the stack (the memory)
3. Math - these instructions allow the CPU to perform mathematical operations
4. Flow - these instructions allow the CPU to perform if's and loops
5. Pseudo Debug - these instructions are used for debugging

 nop
 

 ; stack is [ ]
 push 1 
 ; stack is [ 1 ]
 push 2
 ; stack is [ 1 2 ]
 

 ; stack is [ 1 2 ]
 pop 
 ; stack is [ 1 ]
 

 ; stack is [ 1 2 ]
 load 
 ; stack is [ 1 ]
 ; R is 2
 

 ; stack is [ 1 ]
 ; R is 2
 store 
 ; stack is [ 1 2 ]
 ; R is 2
 

 push 1 
 push 2
 ; stack is [ 1 2 ]
 add 
 ; stack is [ 3 ]
 

 push 1 
 push 2
 ; stack is [ 1 2 ]
 sub 
 ; stack is [ -1 ]
 

 push 1 
 push 2
 ; stack is [ 1 2 ]
 mul 
 ; stack is [ 2 ]
 

 push 1 
 push 2
 ; stack is [ 1 2 ]
 div 
 ; stack is [ 0 ]
 

 push 5 
 push 3
 ; stack is [ 5 3 ]
 mod 
 ; stack is [ 2 ]
 

 ; example with line 
 push 5 ; line 1
 jump 5 ; line 2
 push 3 ; line 3 - skipped
 push 2 ; line 4 - skipped
 push 2 ; line 5 - jump here
 mul
 ; stack is [ 10 ] 

 ; example with label
 push 5 
 jump two 
 push 3 ; skipped
 push 2 ; skipped
 two: push 2 ; label two
 mul
 ; stack is [ 10 ]
 

 ; example ignore
 push 5  
 jumpz two ; ignored, stack top is 5
 push 3 
 push 3 
 two: push 2 
 mul
 ; stack is [ 5 3 6 ] 

 ; example jump
 push 0  
 jumpz two ; jumps, stack top is 0
 push 3 ; skipped
 push 3 ; skipped
 two: push 2 
 mul
 ; stack is [ 0 ]
 

 ; example ignore
 push 5  
 jumpz two ; jumps, stack top is not 0
 push 3 ; skipped
 push 3 ; skipped
 two: push 2 
 mul
 ; stack is [ 10 ] 

 ; example jump
 push 0  
 jumpz two ; ignored, stack top is 0
 push 3 
 push 3 
 two: push 2 
 mul
 ; stack is [ 0 3 6 ]
 

 ; stack is [ 1 2 ]
 print ; prints 2
 

 ; stack is [ 1 2 ]
 stack ; prints [ 1 2 ]
 

The file that the CPU simulator executes might have errors. When the simulator encounters an error, it ignores that instruction and continues the execution with the following line.

The general error format is:

ERROR (instruction_name): error text

multi ; ERROR (multi): unknown instruction

push 1
 mul ; ERROR (mul): stack underflow

$ node index not_a_filename.asm
ERROR unable to open file filename.asm(ENOENT: no such 
file or directory, open 'filename.asm')

jump jumper ; ERROR (jump): undefined label jumper

 jump 2 ; ERROR (mul): invalid jump address 2

To run the simulator, a user will issue the command:

$ node index.js filename.asm

The simulator will read the instructions from the file given as a parameter and execute them.

If no parameter is given, the following message will be displayed:

$ node index.js
USAGE: node index.js filename.asm

The homework tests will have the following format:

All tests will have debug instructions.

The homework has a lot of features that have to be implemented, we suggest you start like this:

1. Read the input file into s string and implement the no file error
2. Split the read input by \n (\r\n if using windows, make sure top change it before you commit to git) string using the split function
3. Split each line by ' ' and extract the instruction and its parameters
4. Implement the unknown instruction error
5. Implement the push and pop instructions using an array of numbers for the stack
6. Implement the math instructions
7. Implement all the instructions

For an additional 2p, implement a memory for the CPU. The simulator will receive another parameter in the command line that represents the number of memory locations available.

Implement the following memory instructions:

1. You may not use RegEx or any other library that would use regular expressions (except \r?\n for splitting the input lines of the source)
2. Source code needs to be indented (-0.1p)
3. You need to explain in details in the Readme.md how you wrote the homework (-1p)

The homework is individual. Any attempt of copying will result in 0p for the homework. Automated anti copying system will be used.

If you have any questions related to the homework, please ask them by posting an issue on the github quiestions repository with the title format [simulator] <your question title>. You will need a github account for that.

If you want to receive an email when issues are posted or when there are new messages, got to the github questions repository and click Watch.