Struct CopyingMemory 

pub struct CopyingMemory {
    pub flat_mem: Vec<u8>,
    pub perms: Vec<u8>,
    pub heap_base: u32,
    pub heap_top: u32,
    pub max_heap_pages: u32,
}

Address-space mapping for one execution context.

Flat-buffer layout matching v2 javm. The buffer’s length defines the upper bound of valid addresses; per-page permissions live in perms. Implements Memory via inherent-method delegation so concrete callers don’t need to import the trait.

Fields

flat_mem: Vec<u8>

Contiguous byte buffer covering 0..flat_mem.len().

perms: Vec<u8>

One permission byte per PAGE_SIZE-page in flat_mem. perms.len() == flat_mem.len() / PAGE_SIZE (rounded up).

heap_base: u32

Heap base address (for sbrk).

heap_top: u32

Current heap top.

max_heap_pages: u32

Maximum heap pages (sbrk refuses beyond this).

Implementations

impl CopyingMemory

pub fn new() -> Self

Empty memory; no pages allocated.

pub fn with_pages(n_pages: u32, default_perm: u8) -> Self

Construct with a pre-sized flat buffer (zero-initialized). n_pages is the number of PAGE_SIZE-pages.

pub fn is_in_bounds(&self, addr: u32) -> bool

Returns true iff addr is within flat_mem.

pub fn perm_of(&self, addr: u32) -> u8

Per-page permission for the page containing addr. Returns perm::NONE if the address is out of range.

pub fn read_u8(&self, addr: u32) -> Option<u8>

pub fn read_u16_le(&self, addr: u32) -> Option<u16>

pub fn read_u32_le(&self, addr: u32) -> Option<u32>

pub fn read_u64_le(&self, addr: u32) -> Option<u64>

pub fn write_u8(&mut self, addr: u32, val: u8) -> bool

pub fn write_u16_le(&mut self, addr: u32, val: u16) -> bool

pub fn write_u32_le(&mut self, addr: u32, val: u32) -> bool

pub fn write_u64_le(&mut self, addr: u32, val: u64) -> bool

pub fn map_region( &mut self, start: u64, size: u64, access: Access, init: Option<&[u8]>, ) -> Result<(), MapError>

Declare a mapped region at [start, start + size) with per-page permissions access and optional initial bytes.

• start and size must each be multiples of PAGE_SIZE.
• Grows flat_mem to cover start + size if necessary (newly-grown bytes are zero-initialized; their pages default to perm::NONE before this call sets them).
• Sets pages in [start / PAGE_SIZE, (start + size) / PAGE_SIZE) to the permission byte for access.
• If init is Some(bytes), copies bytes[..bytes.len() .min(size)] into flat_mem[start..]; the rest of the region remains zero-filled (matches the DataCap canonical form: trailing zeros are stripped from content, but the logical size may be larger).

pub fn read(&self, addr: u32, len: usize) -> Result<Vec<u8>, MemAccess>

Read len bytes from addr. Returns Err on out-of-range.

pub fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), MemAccess>

Write data starting at addr. Returns Err on out-of-range or write-protected page. Writes are NOT rolled back on partial failure (test-only API).

Trait Implementations

impl Clone for CopyingMemory

fn clone(&self) -> CopyingMemory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CopyingMemory

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

Formats the value using the given formatter.

impl Default for CopyingMemory

fn default() -> Self

Returns the “default value” for a type.

impl Memory for CopyingMemory

fn read_u8(&self, addr: u32) -> Option<u8>

fn read_u16_le(&self, addr: u32) -> Option<u16>

fn read_u32_le(&self, addr: u32) -> Option<u32>

fn read_u64_le(&self, addr: u32) -> Option<u64>

fn write_u8(&mut self, addr: u32, val: u8) -> bool

fn write_u16_le(&mut self, addr: u32, val: u16) -> bool

fn write_u32_le(&mut self, addr: u32, val: u32) -> bool

fn write_u64_le(&mut self, addr: u32, val: u64) -> bool

fn map_region( &mut self, start: u64, size: u64, access: Access, init: Option<&[u8]>, ) -> Result<(), MapError>

Declare a mapped region. See CopyingMemory::map_region for the canonical semantics.

fn perm_of(&self, addr: u32) -> u8

Per-page permission byte for the page containing addr. Returns perm::NONE if addr is out of range.

fn read(&self, addr: u32, len: usize) -> Result<Vec<u8>, MemAccess>

Read dst.len() bytes starting at addr into dst.

fn write(&mut self, addr: u32, data: &[u8]) -> Result<(), MemAccess>

Write data.len() bytes starting at addr. Per-page perm checks apply; out-of-range or RO-page writes return Err.