Struct Ram 

pub struct Ram { /* private fields */ }

Main RAM implementation (24MB).

Memory Layout

• data: 24MB byte array (heap allocation required for large size)
• No redundant size field (derived from data.len())

Address Space

GameCube RAM is mapped to:

• Physical addresses: 0x00000000-0x00FFFFFF (24MB)
• Virtual addresses: 0x80000000-0x817FFFFF (24MB)

Implementations

impl Ram

pub fn new() -> Self

Create a new RAM instance with 24MB of memory.

Returns

Ram - Initialized RAM instance with all bytes set to 0

Examples

let ram = Ram::new();

pub fn read_u8(&self, address: u32) -> Result<u8>

Read a single byte from RAM.

Arguments

• address - 32-bit address (24-bit addressing, upper 8 bits masked)

Returns

Result<u8> - Byte value at address, or error if out of bounds

Errors

Returns error if address is out of bounds (>= 24MB)

Examples

let value = ram.read_u8(0x80000000)?;

pub fn read_u16(&self, address: u32) -> Result<u16>

Read a 16-bit word (big-endian) from RAM.

Arguments

• address - 32-bit address (must be aligned, but we don’t enforce it)

Returns

Result<u16> - 16-bit value at address, or error if out of bounds

Errors

Returns error if address+1 is out of bounds

Examples

let value = ram.read_u16(0x80000000)?;

pub fn read_u32(&self, address: u32) -> Result<u32>

Read a 32-bit word (big-endian) from RAM.

Arguments

• address - 32-bit address (must be aligned, but we don’t enforce it)

Returns

Result<u32> - 32-bit value at address, or error if out of bounds

Errors

Returns error if address+3 is out of bounds

Examples

let value = ram.read_u32(0x80000000)?;

pub fn write_u8(&mut self, address: u32, value: u8) -> Result<()>

Write a single byte to RAM.

Arguments

• address - 32-bit address (24-bit addressing, upper 8 bits masked)
• value - Byte value to write

Returns

Result<()> - Success, or error if out of bounds

Errors

Returns error if address is out of bounds (>= 24MB)

Examples

ram.write_u8(0x80000000, 0x42)?;

pub fn write_u16(&mut self, address: u32, value: u16) -> Result<()>

Write a 16-bit word (big-endian) to RAM.

Arguments

• address - 32-bit address (must be aligned, but we don’t enforce it)
• value - 16-bit value to write

Returns

Result<()> - Success, or error if out of bounds

Errors

Returns error if address+1 is out of bounds

Examples

ram.write_u16(0x80000000, 0x1234)?;

pub fn write_u32(&mut self, address: u32, value: u32) -> Result<()>

Write a 32-bit word (big-endian) to RAM.

Arguments

• address - 32-bit address (must be aligned, but we don’t enforce it)
• value - 32-bit value to write

Returns

Result<()> - Success, or error if out of bounds

Errors

Returns error if address+3 is out of bounds

Examples

ram.write_u32(0x80000000, 0x12345678)?;

pub fn read_bytes(&self, address: u32, len: usize) -> Result<Vec<u8>>

Read multiple bytes from RAM.

Arguments

• address - 32-bit address (24-bit addressing, upper 8 bits masked)
• len - Number of bytes to read

Returns

Result<Vec<u8>> - Byte vector, or error if out of bounds

Errors

Returns error if address+len is out of bounds

Examples

let data = ram.read_bytes(0x80000000, 1024)?;

pub fn write_bytes(&mut self, address: u32, data: &[u8]) -> Result<()>

Write multiple bytes to RAM.

Arguments

• address - 32-bit address (24-bit addressing, upper 8 bits masked)
• data - Byte slice to write

Returns

Result<()> - Success, or error if out of bounds

Errors

Returns error if address+data.len() is out of bounds

Examples

ram.write_bytes(0x80000000, &[0x42, 0x43, 0x44])?;

Trait Implementations

impl Debug for Ram

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ram

fn default() -> Self

Returns the “default value” for a type.