Manchester Small-Scale Experimental Machine "Baby" Emulator Library
This library provides a collections of types and methods for emulating & assembling code for the Manchester Baby, the first program stored computer.
The Manchester "Baby" was the first computer to store both its program code and data in a common randomly-accessible memory, it is for this reason the Baby is considered the first machine to run "true" software, providing a familiar (albeit primitive) programming environment to anyone familiar with assembly, this library can be included in a variety of software and platforms allowing emulation functionality of this historic machine.
This library provides an interface for emulating the Baby as a bytecode
baby_emulator::core), and also a library for assembling
asm using both modern and original asm notations into a format that
can be ran by the emulator (
Please log any questions or issues to the GitHub repo.
cargo add baby-emulator
baby-emulator = "0.1.7"
This shows a few short examples of what this library is capable of, designed to be a starting point allowing further experimentation by the "user". See the docs for further examples and info.
Bytecode Interpreter Emulation
The core of this library is
this struct has fields representing all of the Baby's internal
registers and 32 word memory, you can initialise this struct with
an array of
[i32; 32], this array can contain the program code
instructions starting at position 0.
This example runs an example program that adds 5 to 5 and stores
the result in the accumulator. Running here is done with the
method, this method will simply execute sucessive instructions until
either an error is thrown (like a stop instruction), or the number
os iterations exceeds the specified limmit.
use BabyModel; use BabyErrors; use BabyError; let model = new_example_program; match model.run_loop
You can also single step through an emulation, executing a single
instruction at a time using the
execute method and seeing the
use BabyModel; use BabyError; let model = new_example_program; match model.execute
Here is an example of assembling a Baby asm string using
modern notation, then running the resultant program;
baby_emulator::assembler docs for more information:
use assemble; use ; const ASM: &str = " ldn $start_value ; Loads 10 into the accumulator :loop_start_value ; The memory address the loop should return to sub $subtract_val ; Subtract 1 from the accumulator cmp ; Skip the next jump instruction if the accumulator is negative jmp $loop_start ; Jump to the start of the loop stp ; Program stops when the accumulator is negative :loop_start ; Pointer to the memory address the loop should return to abs $loop_start_value :subtract_val ; Value to be subtracted abs 0d1 :start_value ; Value to start in the accumulator abs 0d-10 ";