j/Chirp
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

Rumpulator: Change name to Chumpulator

Browse Source
This commit is contained in:
John
2023-03-10 15:33:36 -06:00
parent f03d03bf4e
commit 2ba807d7a8
10 changed files with 254 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Cargo.lock generated
View File

@@ -2,6 +2,15 @@
# It is not intended for manual editing.
version = 3
[[package]]
name = "chumpulator"
version = "0.1.0"
dependencies = [
"owo-colors",
"serde",
"thiserror",
]
[[package]]
name = "owo-colors"
version = "3.5.0"
@@ -26,15 +35,6 @@ dependencies = [
"proc-macro2",
]
[[package]]
name = "rumpulator"
version = "0.1.0"
dependencies = [
"owo-colors",
"serde",
"thiserror",
]
[[package]]
name = "serde"
version = "1.0.153"

2
Cargo.toml
View File

@@ -1,5 +1,5 @@
[package]
name = "rumpulator"
name = "chumpulator"
version = "0.1.0"
edition = "2021"

2
src/bus.rs
View File

@@ -11,7 +11,7 @@ use std::{
/// Creates a new bus, instantiating BusConnectable devices
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let mut bus = bus! {
/// "RAM" [0x0000..0x8000] Mem::new(0x8000),
/// "ROM" [0x8000..0xFFFF] Mem::new(0x8000).w(false),

4
src/cpu.rs
View File

@@ -73,7 +73,7 @@ impl CPU {
/// Set a general purpose register in the CPU
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// // Create a new CPU, and set v4 to 0x41
/// let cpu = CPU::default()
/// .set_gpr(0x4, 0x41);
@@ -97,7 +97,7 @@ impl CPU {
/// | sp | 0x0efe | Initial top of stack.
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let mut cpu = CPU::new(0xf00, 0x50, 0x200, 0xefe, Disassemble::default());
/// ```
pub fn new(screen: Adr, font: Adr, pc: Adr, sp: Adr, disassembler: Disassemble) -> Self {

232
src/cpu/instruction.rs Normal file
View File

@@ -0,0 +1,232 @@
//! Represents a chip-8 instruction as a Rust enum
use super::{Adr, Nib, Reg};
type Word = Adr;
type Byte = u8;
type Ins = Nib;
/// Extract the instruction nibble from a word
#[inline]
pub fn i(ins: Word) -> Ins {
(ins >> 12) as Ins & 0xf
}
/// Extracts the X-register nibble from a word
#[inline]
pub fn x(ins: Word) -> Reg {
ins as Reg >> 8 & 0xf
}
/// Extracts the Y-register nibble from a word
#[inline]
pub fn y(ins: u16) -> Reg {
ins as Reg >> 4 & 0xf
}
/// Extracts the nibble-sized immediate from a word
#[inline]
pub fn n(ins: Word) -> Nib {
ins as Nib & 0xf
}
/// Extracts the byte-sized immediate from a word
#[inline]
pub fn b(ins: Word) -> Byte {
ins as Byte
}
/// Extracts the address-sized immediate from a word
#[inline]
pub fn a(ins: Word) -> Adr {
ins & 0x0fff
}
/// Restores the instruction nibble into a word
#[inline]
pub fn ii(i: Ins) -> u16 {
(i as Word & 0xf) << 12
}
/// Restores the X-register nibble into a word
#[inline]
pub fn xi(x: Reg) -> Word {
(x as Word & 0xf) << 8
}
/// Restores the Y-register nibble into a word
#[inline]
pub fn yi(y: Reg) -> Word {
(y as Word & 0xf) << 4
}
/// Restores the nibble-sized immediate into a word
#[inline]
pub fn ni(n: Nib) -> Word {
n as Word & 0xf
}
/// Restores the byte-sized immediate into a word
#[inline]
pub fn bi(b: Byte) -> Word {
b as Word
}
/// Captures the operand and type of a Chip-8 instruction
pub enum Chip8Instruction {
Unimplemented(Word),
Clear,
Return,
Sys(Adr),
Jump(Adr),
Call(Adr),
SkipEqualsByte(Reg, Byte),
SkipNotEqualsByte(Reg, Byte),
SkipEquals(Reg, Reg),
LoadImmediate(Reg, Byte),
AddImmediate(Reg, Byte),
Copy(Reg, Reg),
Or(Reg, Reg),
And(Reg, Reg),
Xor(Reg, Reg),
Add(Reg, Reg),
Sub(Reg, Reg),
ShiftRight(Reg, Reg),
BackwardsSub(Reg, Reg),
ShiftLeft(Reg, Reg),
SkipNotEquals(Reg, Reg),
LoadIndirect(Adr),
JumpIndexed(Adr),
Rand(Reg, Byte),
Draw(Reg, Reg, Nib),
SkipEqualsKey(Reg),
SkipNotEqualsKey(Reg),
StoreDelay(Reg),
WaitForKey(Reg),
LoadDelay(Reg),
LoadSound(Reg),
AddIndirect(Reg),
LoadSprite(Reg),
BcdConvert(Reg),
DmaStore(Reg),
DmaLoad(Reg),
}
impl TryFrom<Word> for Chip8Instruction {
type Error = crate::error::Error;
/// Converts a 16-bit word into a Chip8Instruction, when possible.
fn try_from(opcode: Word) -> Result<Self, Self::Error> {
use crate::error::Error::*;
let (i, x, y, n, b, a) = (
i(opcode),
x(opcode),
y(opcode),
n(opcode),
b(opcode),
a(opcode),
);
if i > 0xf {
return Err(FunkyMath {
word: opcode,
explanation: "Instruction nibble greater than 0xf".into(),
});
}
Ok(match i {
// # Issue a system call
// |opcode| effect |
// |------|------------------------------------|
// | 00e0 | Clear screen memory to all 0 |
// | 00ee | Return from subroutine |
0x0 => match a {
0xe0 => Self::Clear,
0xee => Self::Return,
_ => Self::Sys(a),
},
// | 1aaa | Sets pc to an absolute address
0x1 => Self::Jump(a),
// | 2aaa | Pushes pc onto the stack, then jumps to a
0x2 => Self::Call(a),
// | 3xbb | Skips next instruction if register X == b
0x3 => Self::SkipEqualsByte(x, b),
// | 4xbb | Skips next instruction if register X != b
0x4 => Self::SkipNotEqualsByte(x, b),
// # Performs a register-register comparison
// |opcode| effect |
// |------|------------------------------------|
// | 9XY0 | Skip next instruction if vX == vY |
0x5 => match n {
0x0 => Self::SkipEquals(x, y),
_ => Self::Unimplemented(opcode),
},
// 6xbb: Loads immediate byte b into register vX
0x6 => Self::LoadImmediate(x, b),
// 7xbb: Adds immediate byte b to register vX
0x7 => Self::AddImmediate(x, b),
// # Performs ALU operation
// |opcode| effect |
// |------|------------------------------------|
// | 8xy0 | X = Y |
// | 8xy1 | X = X | Y |
// | 8xy2 | X = X & Y |
// | 8xy3 | X = X ^ Y |
// | 8xy4 | X = X + Y; Set vF=carry |
// | 8xy5 | X = X - Y; Set vF=carry |
// | 8xy6 | X = X >> 1 |
// | 8xy7 | X = Y - X; Set vF=carry |
// | 8xyE | X = X << 1 |
0x8 => match n {
0x0 => Self::Copy(x, y),
0x1 => Self::Or(x, y),
0x2 => Self::And(x, y),
0x3 => Self::Xor(x, y),
0x4 => Self::Add(x, y),
0x5 => Self::Sub(x, y),
0x6 => Self::ShiftRight(x, y),
0x7 => Self::BackwardsSub(x, y),
0xE => Self::ShiftLeft(x, y),
_ => Self::Unimplemented(opcode),
},
// # Performs a register-register comparison
// |opcode| effect |
// |------|------------------------------------|
// | 9XY0 | Skip next instruction if vX != vY |
0x9 => match n {
0 => Self::SkipNotEquals(x, y),
_ => Self::Unimplemented(opcode),
},
// Aaaa: Load address #a into register I
0xa => Self::LoadIndirect(a),
// Baaa: Jump to &adr + v0
0xb => Self::JumpIndexed(a),
// Cxbb: Stores a random number & the provided byte into vX
0xc => Self::Rand(x, b),
// Dxyn: Draws n-byte sprite to the screen at coordinates (vX, vY)
0xd => Self::Draw(x, y, n),
// # Skips instruction on value of keypress
// |opcode| effect |
// |------|------------------------------------|
// | eX9e | Skip next instruction if key == #X |
// | eXa1 | Skip next instruction if key != #X |
0xe => match b {
0x9e => Self::SkipEqualsKey(x),
0xa1 => Self::SkipNotEqualsKey(x),
_ => Self::Unimplemented(opcode),
},
// # Performs IO
// |opcode| effect |
// |------|------------------------------------|
// | fX07 | Set vX to value in delay timer |
// | fX0a | Wait for input, store in vX m |
// | fX15 | Set sound timer to the value in vX |
// | fX18 | set delay timer to the value in vX |
// | fX1e | Add x to I |
// | fX29 | Load sprite for character x into I |
// | fX33 | BCD convert X into I[0..3] |
// | fX55 | DMA Stor from I to registers 0..X |
// | fX65 | DMA Load from I to registers 0..X |
0xf => match b {
0x07 => Self::StoreDelay(x),
0x0A => Self::WaitForKey(x),
0x15 => Self::LoadDelay(x),
0x18 => Self::LoadSound(x),
0x1E => Self::AddIndirect(x),
0x29 => Self::LoadSprite(x),
0x33 => Self::BcdConvert(x),
0x55 => Self::DmaStore(x),
0x65 => Self::DmaLoad(x),
_ => Self::Unimplemented(opcode),
},
_ => unreachable!("i somehow mutated from <= 0xf to > 0xf"),
})
}
}

4
src/dump.rs
View File

@@ -5,7 +5,7 @@ use std::ops::Range;
///
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let mem = Mem::new(0x50);
/// // Dumps the first 0x10 bytes
/// mem.dump(0x00..0x10);
@@ -19,7 +19,7 @@ pub trait Dumpable {
///
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let mem = bus! {
/// "mem" [0..0x10] = Mem::new(0x10)
/// };

2
src/error.rs
View File

@@ -1,4 +1,4 @@
//! Error type for rumpulator
//! Error type for chumpulator
use thiserror::Error;

2
src/lib.rs
View File

@@ -15,7 +15,7 @@ pub mod dump;
pub mod error;
pub mod screen;
/// Common imports for rumpulator
/// Common imports for chumpulator
pub mod prelude {
use super::*;
pub use crate::bus;

4
src/main.rs
View File

@@ -1,4 +1,4 @@
use rumpulator::{bus::Read, prelude::*};
use chumpulator::{bus::Read, prelude::*};
use std::fs::read;
fn main() -> Result<(), std::io::Error> {
@@ -8,7 +8,7 @@ fn main() -> Result<(), std::io::Error> {
// Load the ROM file into RAM
"userram" [0x0200..0x0F00] = Mem::new(0xF00 - 0x200).load(0, &read("chip-8/Fishie.ch8")?),
// Create a screen
"screen" [0x0F00..0x1000] = Screen::new(32, 64),
"screen" [0x0F00..0x1000] = Mem::new(32*64/8),
// Create some stack memory
"stack" [0xF000..0xF800] = Mem::new(0x800).r(true).w(true),
};

6
src/mem.rs
View File

@@ -63,7 +63,7 @@ impl Mem {
///
/// # Examples
/// ``` rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let mem = Mem::new(0x100);
/// assert_eq!(mem.len(), 0x100)
/// ```
@@ -84,7 +84,7 @@ impl Mem {
self
}
/// Load a character set from rumpulator/src/mem/charset.bin into this memory section
/// Load a character set from chumpulator/src/mem/charset.bin into this memory section
pub fn load_charset(self, addr: u16) -> Self {
let charset = include_bytes!("mem/charset.bin");
self.load(addr, charset)
@@ -94,7 +94,7 @@ impl Mem {
///
/// # Examples
/// ```rust
/// # use rumpulator::prelude::*;
/// # use chumpulator::prelude::*;
/// let length = 0x100;
/// let mem = Mem::new(length);
/// ```