v0.6.0 release

Author: danielstuart14

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pyembive"
-version = "0.5.0"
+version = "0.6.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,6 +9,6 @@ name = "pyembive"
 crate-type = ["cdylib"]
 
 [dependencies]
-embive = { version = "0.5.0", features = ["alloc"] }
+embive = { version = "0.6.0", features = ["alloc"] }
 ouroboros = "0.18.5"
-pyo3 = "0.25.1"
+pyo3 = "0.26.0"

Cargo.toml

@@ -15,9 +15,9 @@ pub enum ProgramError {
 impl Display for ProgramError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ProgramError::Interpreter(err) => write!(f, "Interpreter error: {}", err),
-            ProgramError::Transpiler(err) => write!(f, "Transpiler error: {}", err),
-            ProgramError::Python(err) => write!(f, "Python error: {}", err),
+            ProgramError::Interpreter(err) => write!(f, "Interpreter error: {err}"),
+            ProgramError::Transpiler(err) => write!(f, "Transpiler error: {err}"),
+            ProgramError::Python(err) => write!(f, "Python error: {err}"),
         }
     }
 }

src/error.rs

@@ -123,7 +123,7 @@ impl Program {
     }
 
     /// Trigger an interrupt.
-    /// 
+    ///
     /// Arguments:
     /// - `value`: 32-bit signed integer value to be passed to the interrupt handler.
     fn interrupt(&mut self, value: i32) -> PyResult<()> {
@@ -139,7 +139,7 @@ impl Program {
     ///
     /// Arguments:
     /// - `syscall_fn`: Python function to call for the syscall.
-    ///     - Example: `def syscall(nr: int, args: List[int], memory: MemoryPy) -> SyscallResult`
+    ///     - Example: `def syscall(nr: int, args: List[int], memory: Memory) -> SyscallResult`
     fn syscall(&mut self, syscall_fn: Bound<'_, PyFunction>) -> PyResult<()> {
         let result = self.interpreter.with_interpreter_mut(|interpreter| {
             interpreter.syscall(&mut |nr,
@@ -215,10 +215,28 @@ impl Program {
             .with_interpreter_mut(|interpreter| interpreter.program_counter = pc);
         Ok(())
     }
+
+    /// Run a function with access to the interpreter memory.
+    ///
+    /// Arguments:
+    /// - `memory_fn`: Python function to call with the memory.
+    ///    - Example: `def memory_fn(memory: Memory) -> None`
+    fn with_memory(&mut self, memory_fn: Bound<'_, PyFunction>) -> PyResult<()> {
+        let result = self.interpreter.with_interpreter_mut(|interpreter| {
+            let fn_scope = |memory: &Py<Memory>| {
+                memory_fn.call1((memory,))?;
+                Ok(())
+            };
+
+            memory_scope(interpreter.memory, fn_scope).map_err(ProgramError::from)
+        });
+
+        result.map_err(|e| e.into())
+    }
 }
 
 /// Embive Python module
-/// 
+///
 /// This module provides the Python bindings for the Embive interpreter and transpiler.
 #[pymodule]
 fn pyembive(m: &Bound<'_, PyModule>) -> PyResult<()> {

src/lib.rs

@@ -13,7 +13,7 @@ pub fn memory_scope<R, F: FnOnce(&Py<Memory>) -> PyResult<R>>(
     memory_wrapper: &mut MemoryWrapper,
     scope: F,
 ) -> PyResult<R> {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let memory = Memory {
             inner: Some(AtomicPtr::new(memory_wrapper as *mut MemoryWrapper)),
         };
@@ -45,7 +45,7 @@ impl Memory {
     ///
     /// Returns:
     /// - `Vec<u8>`: Data loaded from memory.
-    pub fn load(&mut self, address: i32, len: u32) -> PyResult<Vec<u8>> {
+    pub fn load(&mut self, address: i32, len: usize) -> PyResult<Vec<u8>> {
         let address = address as u32;
         let inner = self.inner.as_mut().ok_or_else(|| {
             PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(
@@ -55,7 +55,7 @@ impl Memory {
 
         // Safety: Pointer is valid for as long as the struct is valid, borrow is guarded by pyo3 (this function is mutable).
         let memory = unsafe { &mut **inner.get_mut() };
-        let result = memory.load(address, len).map_err(ProgramError::from);
+        let result = memory.load_bytes(address, len).map_err(ProgramError::from);
 
         result.map(|data| data.to_vec()).map_err(|e| e.into())
     }
@@ -75,7 +75,9 @@ impl Memory {
 
         // Safety: Pointer is valid for as long as the struct is valid, borrow is guarded by pyo3 (this function is mutable).
         let memory = unsafe { &mut **inner.get_mut() };
-        let result = memory.store(address, &data).map_err(ProgramError::from);
+        let result = memory
+            .store_bytes(address, &data)
+            .map_err(ProgramError::from);
 
         result.map_err(|e| e.into())
     }

src/memory.rs

@@ -27,12 +27,27 @@ impl MemoryWrapper {
 }
 
 impl Memory for MemoryWrapper {
-    fn load(&mut self, address: u32, len: u32) -> Result<&[u8], embive::interpreter::Error> {
-        self.0.with_memory_mut(|memory| memory.load(address, len))
+    fn load_bytes(
+        &mut self,
+        address: u32,
+        len: usize,
+    ) -> Result<&[u8], embive::interpreter::Error> {
+        self.0
+            .with_memory_mut(|memory| memory.load_bytes(address, len))
     }
 
-    fn store(&mut self, address: u32, data: &[u8]) -> Result<(), embive::interpreter::Error> {
-        self.0.with_memory_mut(|memory| memory.store(address, data))
+    fn mut_bytes(
+        &mut self,
+        address: u32,
+        len: usize,
+    ) -> Result<&mut [u8], embive::interpreter::Error> {
+        self.0
+            .with_memory_mut(|memory| memory.mut_bytes(address, len))
+    }
+
+    fn store_bytes(&mut self, address: u32, data: &[u8]) -> Result<(), embive::interpreter::Error> {
+        self.0
+            .with_memory_mut(|memory| memory.store_bytes(address, data))
     }
 }
 
@@ -48,12 +63,8 @@ pub struct InterpreterWrapper(InterpreterInner);
 
 impl InterpreterWrapper {
     pub fn new(memory: MemoryWrapper, instruction_limit: u32) -> Self {
-        let interpreter = InterpreterInner::new(memory, |memory| {
-            Interpreter::new(
-                memory,
-                instruction_limit,
-            )
-        });
+        let interpreter =
+            InterpreterInner::new(memory, |memory| Interpreter::new(memory, instruction_limit));
         InterpreterWrapper(interpreter)
     }