# Using the Debugger

When use of the debugger is enabled and an error occurs, Magma will break into the command-line debugger. The syntax of the debugger is modelled on the GNU GDB debugger for C programs, and supports the following commands (acceptable abbreviations for the commands are given in parentheses):

**`backtrace (bt)`**
Print out the stack of function and procedure calls, from the top level to the point at which the error occurred. Each line in this trace gives a single *frame*, which consists of the function/procedure that was called, as well as all local variable definitions for that function. Each frame is numbered so that it can be referenced in other debugger commands.

**`frame (f)` $n$**
Change the current frame to the frame numbered $n$ (the list of frames can be obtained using the `backtrace` command). The current frame is used by other debugger commands, such as `print`, to determine the context within which expressions should be evaluated. The default current frame is the top-most frame.

**`list (l) [n]`**
Print a source code listing for the current context (the context is set by the `frame` command). If $n$ is specified, then the `list` command will print $n$ lines of source code; the default value is $10$.

**`print (p)` $expr$**
Evaluate the expression $expr$ in the current context (the context is set by the `frame` command). The `print` command has semantics identical to evaluating the expression `eval "expr"` at the current point in the program.

**`identifiers (id)`**
Print a list of the assigned identifiers in the current context (the context is set by the `frame` command). The `identifiers` command is equivalent to invoking the `ShowIdentifiers` intrinsic at the current point in the program.

**`help (h)`**
Print brief help on usage.

**`quit (q)`**
Quit the debugger and return to the Magma session.

## `Example: Debugger Example (ex-12f5cb)`

We now give a sample session in the debugger. In the following, we have written a function to evaluate $f(n) = \Sigma_{i=1}^n 1 / i$, but in our implementation we have accidentally included the evaluation of the term at $n = 0$.

```magma
> function f(n)
>   if n ge 0 then
>      return 1.0 / n + f(n - 1);
>   else
>      return 1.0 / n;
>   end if;
> end function;
>
> SetDebugOnError(true);
> f(3);

f(
    n: 3
)
f(
    n: 2
)
f(
    n: 1
)
f(
    n: 0
)
>>      return 1.0 / n + f(n - 1);
                   ^
Runtime error in '/': Division by zero

debug> p n
0
debug> p 1.0 / (n + 1)
1.00000000000000000000000000000
debug> bt
#0 *f(
    n: 0
) at <main>:1
#1  f(
    n: 1
) at <main>:1
#2  f(
    n: 2
) at <main>:1
#3  f(
    n: 3
) at <main>:1
debug> f 1
debug> p n
1
debug> p 1.0 / n
1.00000000000000000000000000000

```