5. Bdb The ``Bigloo Debugger'' Nov 1999 -- Continuing execution after a breakpoint

main page

top: | Bdb The ``Bigloo Debugger'' Nov 1999

Continuing execution after a breakpoint

Chapters

When the execution has stopped at a breakpoint several commands allow the execution to be resumed:
You may use any of the GDB commands to resume an execution No distinction is made between Bigloo and C code. That is, it is possible when stepping a Bigloo function to enter a C function and vice versa. BDB does not try to hide the execution of C functions. Each code compiled in debug mode is visible from BDB.

`continue [IGNORE-COUNT]`
``
`c [IGNORE-COUNT]`
``
  Resume program execution at the address where your program last stopped; any breakpoints set at that address are bypassed. The optional argument IGNORE-COUNT allows you to specify a further number of times to ignore a breakpoint at this location.
`step [COUNT]`
``
`s [COUNT]`
``
  Continue running your program until control reaches a different Scheme source line, then stop it and return control to BDB. This command is abbreviated `bs`.
`next [COUNT]`
``
`n [COUNT]`
``
  Continue to the next source line in the current (innermost) stack frame. This is similar to `step`, but function calls that appear within the line of code are executed without stopping. Execution stops when control reaches a different line of code at the original stack level that was executing when you gave the `next` command. This command is abbreviated `n`.
  An argument COUNT is a repeat count, as for `step`.
  The `next` command now only stops at the first instruction of a source line. This prevents the multiple stops that used to occur in switch statements, for loops, etc.
`finish`
``
`f`
``
  Continue running until just after the function in the selected stack frame returns. Print the returned value (if any).
`until`
``
`u`
``
  Continue running until a source line past the current line, in the current stack frame, is reached. This command is used to avoid single stepping through a loop more than once. It is like the `next` command, except that when `until` encounters a jump, it automatically continues execution until the program counter is greater than the address of the jump.
  This means that when you reach the end of a loop after single stepping through it, `until` makes your program continue execution until it exits the loop. In contrast, a `next' command at the end of a loop simply steps back to the beginning of the loop, which forces you to step through the next iteration.
  `until` always stops your program if it attempts to exit the current stack frame.
`return [EXPRESSION]`
``
`r [EXPRESSION]`
``
  You may return from a function, using the `return` GDB command This cancels the execution of a function call. If you give an `EXPRESSION` argument, its value is used as the function's return value.

This Html page has been produced by Skribe.
Last update Thu Jan 24 17:08:37 2013.