e8Bit Emulator

This project is a simple 8-bit virtual machine (VM) emulator written in Rust. It simulates a basic CPU with registers, memory, and a set of instructions for performing arithmetic, memory operations, and control flow.

Features

• Registers: Four general-purpose 8-bit registers (A, B, C, D).
• Memory: 256 bytes of memory.
• Instruction Set:
  • Arithmetic: ADD, SUB, MUL, DIV
  • Data Movement: MOV, STORE
  • Memory Access: Supports [0], [A], [B], etc.
  • Control Flow: JMP, JZ, JNZ, LOOP
  • Input/Output: INPUT, PRINT, PRINTCH
  • Program Termination: HALT
• Zero Flag: Tracks whether the result of the last operation was zero.
• Custom Parsing: Accepts comments (//) and instruction separation via ; or by lines.
• Character Literals: Supports character literals in instructions, e.g., MOV A 'p'. Characters are internally treated as their ASCII numeric values and must fit within 8 bits (0–255), just like any other number.

Example Program

The files example.e8 and example.e8 contain examples of programs that demonstrate the use of registers, arithmetic operations, memory storage, and loops.

// FACTORIAL SCRIPT

// registers
MOV A 1;           // A = 1 (result)
MOV B 5;           // B = 5 (number to get factorial)

// loop starts here (index 2)
MUL A B;           // A *= B
SUB B 1;           // B -= 1
LOOP 2 B;           // if B != 0 go to index 2 (MUL A B)

// END
PRINT A;           // shows result
HALT;

// WELCOME SCRIPT

MOV C 0;

INPUT A;

STORE A [C];
ADD C 1;
INPUT A;
JNZ 2;          // If nothing in the input continue, else go back

// Welcome message

MOV D 'H';       // H
PRINTCH D -N;
MOV D 'e';      // e
PRINTCH D -N;
MOV D 'l';      // l
PRINTCH D -N;
PRINTCH D -N;
MOV D 111;      // o
PRINTCH D -N;
MOV D ',';       // ,
PRINTCH D -N;
MOV D 32;       //  
PRINTCH D -N;

// Hello, 

MOV D 0;
MOV A [D];
PRINTCH A -N;   // No line break
ADD D 1;
MOV B C;
SUB B D;
JNZ 20;

// Hello, (name)

HALT

How to Run

1. Install Rust: Ensure you have Rust installed. You can download it from rust-lang.org.
2. Compile the Program:

   cargo build --release
   

3. Run the Emulator:

   cargo run -- example.e8
   

   Replace example.e8 with the path to your program file.

How to Write Programs

Programs for the emulator are written in a custom assembly-like language. Each instruction is written on a new line and can include comments starting with //. Refer to the example program above for syntax.

Instruction Set

Args Types

Note: Square brackets ([]) are used to specify memory addresses. For example:

• MOV A [0] loads the value from memory address 0 into register A.
• STORE A [0] stores the value of register A into memory address 0.

Args Types Supported

Future Improvements

• Add support for more instructions.
• Implement debugging tools.
• Enhance error handling for invalid programs.

License

This project is open-source and available under the MIT License.