Add debugger state

Author: ddoktorski

src/debugger.rs

@@ -1,61 +1,55 @@
-use anyhow::{Result, bail};
+use anyhow::Result;
 use cairo_vm::vm::vm_core::VirtualMachine;
 use dap::events::ExitedEventBody;
 use dap::prelude::Event::{Exited, Terminated};
-use tracing::{debug, error};
+use tracing::error;
 
 use crate::connection::Connection;
-use crate::debugger::handler::{HandleResult, NextAction};
+use crate::debugger::state::State;
 
 mod handler;
+mod state;
 mod vm;
 
 pub struct CairoDebugger {
     connection: Connection,
+    state: State,
 }
 
 impl CairoDebugger {
     pub fn connect_and_initialize() -> Result<Self> {
         let connection = Connection::new()?;
-        let debugger = Self { connection };
+        let mut debugger = Self { connection, state: State::new() };
         debugger.initialize()?;
 
         Ok(debugger)
     }
 
-    fn initialize(&self) -> Result<()> {
-        loop {
+    fn initialize(&mut self) -> Result<()> {
+        while !self.state.is_configuration_done() {
             // TODO(#35)
             let request = self.connection.next_request()?;
-            if let HandleResult::Trigger(NextAction::FinishInit) = self.handle_request(request)? {
-                debug!("Initialization finished");
-                break;
-            }
+            self.handle_request(request)?;
         }
 
         Ok(())
     }
 
-    fn sync_with_vm(&self, _vm: &VirtualMachine) -> Result<()> {
-        while let Some(request) = self.connection.try_next_request()?
-            && let HandleResult::Trigger(NextAction::Stop) = self.handle_request(request)?
-        {
-            self.process_until_resume()?;
+    fn sync_with_vm(&mut self, _vm: &VirtualMachine) -> Result<()> {
+        while let Some(request) = self.connection.try_next_request()? {
+            self.handle_request(request)?;
+            if self.state.is_execution_stopped() {
+                self.process_until_resume()?;
+            }
         }
 
         Ok(())
     }
 
-    fn process_until_resume(&self) -> Result<()> {
-        loop {
+    fn process_until_resume(&mut self) -> Result<()> {
+        while self.state.is_execution_stopped() {
             let request = self.connection.next_request()?;
-            match self.handle_request(request)? {
-                HandleResult::Trigger(NextAction::Resume) => break,
-                HandleResult::Trigger(NextAction::FinishInit) => {
-                    bail!("Unexpected request received during execution");
-                }
-                HandleResult::Handled | HandleResult::Trigger(NextAction::Stop) => {}
-            }
+            self.handle_request(request)?;
         }
 
         Ok(())

src/debugger/handler.rs

@@ -10,19 +10,8 @@ use tracing::trace;
 
 use crate::CairoDebugger;
 
-pub enum HandleResult {
-    Handled,
-    Trigger(NextAction),
-}
-
-pub enum NextAction {
-    Resume,
-    Stop,
-    FinishInit,
-}
-
 impl CairoDebugger {
-    pub fn handle_request(&self, request: Request) -> Result<HandleResult> {
+    pub fn handle_request(&mut self, request: Request) -> Result<()> {
         match &request.command {
             // We have not yet decided if we want to support these.
             Command::BreakpointLocations(_)
@@ -89,20 +78,21 @@ impl CairoDebugger {
                     }),
                 )?;
                 self.connection.send_event(Event::Initialized)?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
             Command::Launch(_) => {
                 self.connection.send_success(request, ResponseBody::Launch)?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
             Command::ConfigurationDone => {
                 // Start running the Cairo program here.
-                trace!("Configuration done");
+                self.state.set_configuration_done();
                 self.connection.send_success(request, ResponseBody::ConfigurationDone)?;
-                Ok(HandleResult::Trigger(NextAction::FinishInit))
+                Ok(())
             }
 
             Command::Pause(_) => {
+                self.state.stop_execution();
                 self.connection.send_event(Event::Stopped(StoppedEventBody {
                     reason: StoppedEventReason::Pause,
                     thread_id: Some(0),
@@ -113,14 +103,15 @@ impl CairoDebugger {
                     hit_breakpoint_ids: None,
                 }))?;
                 self.connection.send_success(request, ResponseBody::Pause)?;
-                Ok(HandleResult::Trigger(NextAction::Stop))
+                Ok(())
             }
             Command::Continue(_) => {
+                self.state.resume_execution();
                 self.connection.send_success(
                     request,
                     ResponseBody::Continue(ContinueResponse { all_threads_continued: Some(true) }),
                 )?;
-                Ok(HandleResult::Trigger(NextAction::Resume))
+                Ok(())
             }
 
             Command::SetBreakpoints(args) => {
@@ -142,7 +133,7 @@ impl CairoDebugger {
                         breakpoints: response_bps,
                     }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
 
             Command::Threads => {
@@ -153,7 +144,7 @@ impl CairoDebugger {
                         threads: vec![Thread { id: 0, name: "".to_string() }],
                     }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
             Command::StackTrace(_) => {
                 self.connection.send_success(
@@ -172,15 +163,15 @@ impl CairoDebugger {
                         total_frames: Some(1),
                     }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
             Command::Scopes(_) => {
                 // Return no scopes.
                 self.connection.send_success(
                     request,
                     ResponseBody::Scopes(ScopesResponse { scopes: vec![] }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
             Command::Variables(_) => {
                 self.connection.send_success(
@@ -190,7 +181,7 @@ impl CairoDebugger {
                         variables: vec![],
                     }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
 
             Command::Next(_) => {
@@ -220,7 +211,7 @@ impl CairoDebugger {
                         memory_reference: None,
                     }),
                 )?;
-                Ok(HandleResult::Handled)
+                Ok(())
             }
 
             Command::Disconnect(_) => {

src/debugger/state.rs

@@ -0,0 +1,35 @@
+use tracing::trace;
+
+pub struct State {
+    configuration_done: bool,
+    execution_stopped: bool,
+}
+
+impl State {
+    pub fn new() -> Self {
+        Self { configuration_done: false, execution_stopped: false }
+    }
+
+    pub fn is_configuration_done(&self) -> bool {
+        self.configuration_done
+    }
+
+    pub fn set_configuration_done(&mut self) {
+        trace!("Configuration done");
+        self.configuration_done = true;
+    }
+
+    pub fn is_execution_stopped(&self) -> bool {
+        self.execution_stopped
+    }
+
+    pub fn stop_execution(&mut self) {
+        trace!("Execution stopped");
+        self.execution_stopped = true;
+    }
+
+    pub fn resume_execution(&mut self) {
+        trace!("Execution resumed");
+        self.execution_stopped = false;
+    }
+}