This is a CPU emulator written in Python, without dependencies. This project is compatible with both Python 2.7 and 3.x. The size of instructions and memory cells are 16 bits. The specs for this project (CPU instructions and architecture) are heavily inspired by 16bitjs by Francis Strokes. This project consists of:

• An emulator written in Python.
• An assembler written in Python.
• Tests, you'll never guess it, also written in Python.
• A Brainfuck interpreter written in assembly that can be assembled with the included assembler.

See also RCPU_C, a somewhat limited RCPU emulator written in C.

See also RCPU_FPGA for an actual implementation of RCPU in hardware.

Just clone the GitHub repo

git clone https://github.com/redfast00/RCPU

Assemble an assembly file with:

python -m RCPU.assemble asm/printf.asm printf.out

and then execute it with:

python -m RCPU.emulate printf.out

To use the Brainfuck interpreter, just do:

python -m RCPU.assemble asm/brainfuck.asm brainfuck.out
python -m RCPU.emulate brainfuck.out

If you want easier aliases, you can install the project with:

python setup.py install

and then you can run the commands like:

rcpu_assemble asm/printf.asm printf.out
rcpu_emulate printf.out

Every instruction consists of 16 bits: the last 4 bits are the opcode (indicating which instruction is used), the first 12 bits indicate the arguments. For example, the instruction 00000000 11 00 0000 (spaces added for clarity) is a MOV instruction that copies the value in the A register to the D register.

If there are any X in the instructions, that means that the value is ignored. It's good practice to set these to 0. Note that when assembling to a file, these instructions are big endian.

These pseudo-instructions aren't real instructions, but are macros implemented in the assembler that can consist of multiple instructions.

These are the possible values for the O (operation) argument in the ATH instruction.

Syscall numbers and arguments are passed via the stack. The syscall number should be on top of the stack, followed by any arguments needed.

For example the assembly code to call printf '%d' 20:

.data
  .format string '%d'
  .printf 0

.text
  .global main:

main:
  ; Push 20
  LDV A, 20
  PSH A
  ; Push the address of the format string
  LDV A, .format
  PSH A
  ; Push the syscall number
  LDV A, .printf
  PSH A
  sys
  hlt

• Assembler
  • add support for including files (*.inc)
  • write .inc file for all syscalls
  • add support for macro's
  • add more expanders
    • conditional branching (JNE, JGE, JEQ, JGT, JLE)
  • add a way to reserve memory for strings
  • add support for escaped characters in string
  • add optimizing step (for example, remove POP A, PSH A sequences)
• CPU: add more syscalls
  • reading stdin
  • parsing input from stdin
  • reading/writing to files
• Docs
  • Add branching pseudo-instructions + mention side effects (none :) )
• Make a compiler for a certain language (maybe a language like Forth?)
• Write more tests, get coverage to 100%
  • Assembler and emulator scripts