This is an automated email from the ASF dual-hosted git repository.
shanedell pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/daffodil-vscode.git
The following commit(s) were added to refs/heads/main by this push:
new 9c3cfd2 Mimic step over code for step in and step out
9c3cfd2 is described below
commit 9c3cfd2a436bee68107951ac4e1c88adc2d8c3e2
Author: Shane Dell <[email protected]>
AuthorDate: Mon Oct 27 11:40:25 2025 -0400
Mimic step over code for step in and step out
- Renamed step to stepOver.
- Step in and step out now perform the same behavior as step over.
- In the future, step over and step out will need to be updated to perform
their proper behavior.
- Step in's current behavior is correct so it does not need changed in
the future.
- Create performStep function that will be used in the future for
implementing step over and step out's desired behavior.
- These changed are to prevent the debugger from erroring out when clicking
the step in or step out buttons.
Closes #1466
---
.../org.apache.daffodil.debugger.dap/DAPodil.scala | 39 ++++++++++++++++--
.../org.apache.daffodil.debugger.dap/Parse.scala | 48 ++++++++++++++++++----
2 files changed, 74 insertions(+), 13 deletions(-)
diff --git
a/debugger/src/main/scala/org.apache.daffodil.debugger.dap/DAPodil.scala
b/debugger/src/main/scala/org.apache.daffodil.debugger.dap/DAPodil.scala
index d2458ac..da4a572 100644
--- a/debugger/src/main/scala/org.apache.daffodil.debugger.dap/DAPodil.scala
+++ b/debugger/src/main/scala/org.apache.daffodil.debugger.dap/DAPodil.scala
@@ -193,6 +193,10 @@ class DAPodil(
disconnect(request, args)
case extract(Command.EVALUATE, args: EvaluateArguments) =>
eval(request, args)
+ case extract(Command.STEPIN, _) =>
+ stepIn(request)
+ case extract(Command.STEPOUT, _) =>
+ stepOut(request)
case _ =>
session.abort(ErrorEvent.UnhandledRequest(show"unhandled request
$request"), show"unhandled request $request")
}
@@ -328,7 +332,7 @@ class DAPodil(
state.get.flatMap {
case DAPodil.State.Launched(debugee) =>
for {
- _ <- debugee.step()
+ _ <- debugee.stepOver()
_ <- session.sendResponse(request.respondSuccess())
} yield ()
case s => DAPodil.InvalidState.raise(request, "Launched", s)
@@ -426,6 +430,26 @@ class DAPodil(
} yield ()
case s => DAPodil.InvalidState.raise(request, "Launched", s)
}
+
+ def stepIn(request: Request): IO[Unit] =
+ state.get.flatMap {
+ case DAPodil.State.Launched(debugee) =>
+ for {
+ _ <- debugee.stepIn()
+ _ <- session.sendResponse(request.respondSuccess())
+ } yield ()
+ case s => DAPodil.InvalidState.raise(request, "Launched", s)
+ }
+
+ def stepOut(request: Request): IO[Unit] =
+ state.get.flatMap {
+ case DAPodil.State.Launched(debugee) =>
+ for {
+ _ <- debugee.stepOut()
+ _ <- session.sendResponse(request.respondSuccess())
+ } yield ()
+ case s => DAPodil.InvalidState.raise(request, "Launched", s)
+ }
}
object DAPodil extends IOApp {
@@ -559,7 +583,10 @@ object DAPodil extends IOApp {
.compile
.lastOrError
- def step(): IO[Unit]
+ def stepOver(): IO[Unit]
+ def stepIn(): IO[Unit]
+ def stepOut(): IO[Unit]
+
def continue(): IO[Unit]
def pause(): IO[Unit]
def setBreakpoints(uri: URI, lines: List[DAPodil.Line]): IO[Unit]
@@ -576,7 +603,9 @@ object DAPodil extends IOApp {
object Stopped {
def entry: Stopped = Stopped(Reason.Entry)
def pause: Stopped = Stopped(Reason.Pause)
- def step: Stopped = Stopped(Reason.Step)
+ def stepOver: Stopped = Stopped(Reason.StepOver)
+ def stepIn: Stopped = Stopped(Reason.StepIn)
+ def stepOut: Stopped = Stopped(Reason.StepOut)
def breakpointHit(location: DAPodil.Location): Stopped =
Stopped(Reason.BreakpointHit(location))
sealed trait Reason
@@ -592,7 +621,9 @@ object DAPodil extends IOApp {
case object Pause extends Reason
/** The user requested a step, which completed, so now we are
stopped again. */
- case object Step extends Reason
+ case object StepOver extends Reason
+ case object StepIn extends Reason
+ case object StepOut extends Reason
/** A breakpoint was hit. */
case class BreakpointHit(location: DAPodil.Location) extends Reason
diff --git
a/debugger/src/main/scala/org.apache.daffodil.debugger.dap/Parse.scala
b/debugger/src/main/scala/org.apache.daffodil.debugger.dap/Parse.scala
index 810dc7a..442a79b 100644
--- a/debugger/src/main/scala/org.apache.daffodil.debugger.dap/Parse.scala
+++ b/debugger/src/main/scala/org.apache.daffodil.debugger.dap/Parse.scala
@@ -180,11 +180,27 @@ object Parse {
def sourceChanges(): Stream[IO, DAPodil.Source] =
Stream.empty
- def step(): IO[Unit] =
- control.step() *> parseEvents
+ def stepOver(): IO[Unit] =
+ control.stepOver() *> parseEvents
.send(
Parse.Event
- .Control(DAPodil.Debugee.State.Stopped.step)
+ .Control(DAPodil.Debugee.State.Stopped.stepOver)
+ )
+ .void
+
+ def stepIn(): IO[Unit] =
+ control.stepIn() *> parseEvents
+ .send(
+ Parse.Event
+ .Control(DAPodil.Debugee.State.Stopped.stepIn)
+ )
+ .void
+
+ def stepOut(): IO[Unit] =
+ control.stepOut() *> parseEvents
+ .send(
+ Parse.Event
+ .Control(DAPodil.Debugee.State.Stopped.stepOut)
)
.void
@@ -736,7 +752,7 @@ object Parse {
startup = dapEvents.send(ConfigEvent(args)) *>
(if (args.stopOnEntry)
- control.step() *>
+ control.stepIn() *>
events.send(Parse.Event.Control(DAPodil.Debugee.State.Stopped.entry))
// don't use debugee.step as we need to send Stopped.entry, not
Stopped.step
else debugee.continue())
@@ -806,8 +822,12 @@ object Parse {
new Events.StoppedEvent("entry", 1L)
case DAPodil.Debugee.State.Stopped.Reason.Pause =>
new Events.StoppedEvent("pause", 1L)
- case DAPodil.Debugee.State.Stopped.Reason.Step =>
- new Events.StoppedEvent("step", 1L)
+ case DAPodil.Debugee.State.Stopped.Reason.StepOver =>
+ new Events.StoppedEvent("stepOver", 1L)
+ case DAPodil.Debugee.State.Stopped.Reason.StepIn =>
+ new Events.StoppedEvent("stepIn", 1L)
+ case DAPodil.Debugee.State.Stopped.Reason.StepOut =>
+ new Events.StoppedEvent("stepOut", 1L)
case
DAPodil.Debugee.State.Stopped.Reason.BreakpointHit(location) =>
new Events.StoppedEvent("breakpoint", 1L, false,
show"Breakpoint hit at $location", null)
},
@@ -1239,7 +1259,9 @@ object Parse {
* IMPORTANT: Shouldn't return until any work blocked by an `await`
completes, otherwise the update that was
* waiting will race with the code that sees the `step` complete.
*/
- def step(): IO[Unit]
+ def stepOver(): IO[Unit]
+ def stepIn(): IO[Unit]
+ def stepOut(): IO[Unit]
/** Stop running. */
def pause(): IO[Unit]
@@ -1274,13 +1296,17 @@ object Parse {
}.flatten
} yield awaited
- def step(): IO[Unit] =
+ def performStep(stepType: String): IO[Unit] =
for {
nextContinue <- Deferred[IO, Unit]
nextAwaitStarted <- Deferred[IO, Unit]
_ <- state.modify {
case s @ AwaitingFirstAwait(waiterArrived) =>
- s -> waiterArrived.get *> step()
+ s -> waiterArrived.get *> (stepType match {
+ case "stepOver" => stepOver()
+ case "stepIn" => stepIn()
+ case "stepOut" => stepOut()
+ })
case Running => Running -> IO.unit
case Stopped(whenContinued, _) =>
Stopped(nextContinue, nextAwaitStarted) -> (
@@ -1290,6 +1316,10 @@ object Parse {
}.flatten
} yield ()
+ def stepOver(): IO[Unit] = performStep("stepOver")
+ def stepIn(): IO[Unit] = performStep("stepIn")
+ def stepOut(): IO[Unit] = performStep("stepOut")
+
def continue(): IO[Unit] =
state.modify {
case s @ AwaitingFirstAwait(waiterArrived) =>
