.TH i 3erl "debugger 5.3.1.2" "Ericsson AB" "Erlang Module Definition"
.SH NAME
i \- Debugger/Interpreter Interface.
.SH DESCRIPTION
.LP
The \fIi\fR\& module provides short forms for some of the functions used by the graphical Debugger and some of the functions in module \fIint\fR\&, the Erlang interpreter\&.
.LP
This module also provides facilities for displaying status information about interpreted processes and break points\&.
.LP
It is possible to attach to interpreted processes by giving the corresponding process identity only\&. By default, an attachment window is displayed\&. Processes at other Erlang nodes can be attached manually or automatically\&.
.LP
By preference, these functions can be included in module \fIshell_default\fR\&\&. By default, they are included in that module\&.
.SH EXPORTS
.LP
.B
im() -> pid()
.br
.RS
.LP
Starts a new graphical monitor\&. This is the Monitor window, the main window of Debugger\&. All the Debugger and interpreter functionality is accessed from the Monitor window\&. This window displays the status of all processes that have been or are executing interpreted modules\&.
.RE

.LP
.B
ii(AbsModules) -> ok
.br
.B
ii(AbsModule) -> {module, Module} | error
.br
.B
ini(AbsModules) -> ok
.br
.B
ini(AbsModule) -> {module, Module} | error
.br
.RS
.LP
Types:

.RS 3
AbsModules = [AbsModule]
.br
AbsModule = Module | File
.br
 Module = atom()
.br
 File = string()
.br
.RE
.RE
.RS
.LP
Interprets the specified module(s)\&. \fIii/1\fR\& interprets the module(s) only at the current node, see int:i/1\&. \fIini/1\fR\& interprets the module(s) at all known nodes, see int:ni/1\&.
.RE

.LP
.B
iq(AbsModule) -> ok
.br
.B
inq(AbsModule) -> ok
.br
.RS
.LP
Types:

.RS 3
AbsModule = Module | File
.br
 Module = atom()
.br
 File = string()
.br
.RE
.RE
.RS
.LP
Stops interpreting the specified module\&. \fIiq/1\fR\& stops interpreting the module only at the current node\&. \fIinq/1\fR\& stops interpreting the module at all known nodes\&.
.RE

.LP
.B
il() -> ok
.br
.RS
.LP
Makes a printout of all interpreted modules\&. Modules are printed together with the full path name of the corresponding source code file\&.
.RE

.LP
.B
ip() -> ok
.br
.RS
.LP
Prints the current status of all interpreted processes\&.
.RE

.LP
.B
ic() -> ok
.br
.RS
.LP
Clears information about processes executing interpreted code by removing all information about terminated processes\&.
.RE

.LP
.B
iaa(Flags) -> true
.br
.B
iaa(Flags, Function) -> true
.br
.RS
.LP
Types:

.RS 3
Flags = [init | break | exit]
.br
Function = {Module,Name,Args}
.br
 Module = Name = atom()
.br
 Args = [term()]
.br
.RE
.RE
.RS
.LP
Sets when and how to attach to a debugged process automatically, see int:auto_attach/2\&. \fIFunction\fR\& defaults to the standard function used by Debugger\&.
.RE

.LP
.B
ist(Flag) -> true
.br
.RS
.LP
Types:

.RS 3
Flag = all | no_tail | false
.br
.RE
.RE
.RS
.LP
Sets how to save call frames in the stack, see int:stack_trace/1\&.
.RE

.LP
.B
ia(Pid) -> ok | no_proc
.br
.RS
.LP
Types:

.RS 3
Pid = pid()
.br
.RE
.RE
.RS
.LP
Attaches to the debugged process \fIPid\fR\&\&. An Attach Process window is opened for the process\&.
.RE

.LP
.B
ia(X,Y,Z) -> ok | no_proc
.br
.RS
.LP
Types:

.RS 3
X = Y = Z = int()
.br
.RE
.RE
.RS
.LP
Same as \fIia(Pid)\fR\&, where \fIPid\fR\& is the result of calling the shell function \fIpid(X,Y,Z)\fR\&\&.
.RE

.LP
.B
ia(Pid, Function) -> ok | no_proc
.br
.RS
.LP
Types:

.RS 3
Pid = pid()
.br
Function = {Module,Name}
.br
 Module = Name = atom()
.br
.RE
.RE
.RS
.LP
Attaches to the debugged process \fIPid\fR\&\&. The interpreter calls \fIspawn(Module, Name, [Pid])\fR\& (and ignores the result)\&.
.RE

.LP
.B
ia(X,Y,Z, Function) -> ok | no_proc
.br
.RS
.LP
Types:

.RS 3
X = Y = Z = int()
.br
Function = {Module,Name}
.br
 Module = Name = atom()
.br
.RE
.RE
.RS
.LP
Same as \fIia(Pid, Function)\fR\&, where \fIPid\fR\& is the result of calling the shell function \fIpid(X,Y,Z)\fR\&\&. An attached process is expected to call the unofficial function \fIint:attached(Pid)\fR\& and to be able to handle messages from the interpreter\&. For an example, see \fIdbg_wx_trace\&.erl\fR\&\&.
.RE

.LP
.B
ib(Module, Line) -> ok | {error, break_exists}
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
.RE
.RE
.RS
.LP
Creates a breakpoint at \fILine\fR\& in \fIModule\fR\&\&.
.RE

.LP
.B
ib(Module, Name, Arity) -> ok | {error, function_not_found} 
.br
.RS
.LP
Types:

.RS 3
Module = Name = atom()
.br
Arity = int()
.br
.RE
.RE
.RS
.LP
Creates breakpoints at the first line of every clause of function \fIModule:Name/Arity\fR\&\&.
.RE

.LP
.B
ir() -> ok
.br
.RS
.LP
Deletes all breakpoints\&.
.RE

.LP
.B
ir(Module) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
.RE
.RE
.RS
.LP
Deletes all breakpoints in \fIModule\fR\&\&.
.RE

.LP
.B
ir(Module, Line) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
.RE
.RE
.RS
.LP
Deletes the breakpoint at \fILine\fR\& in \fIModule\fR\&\&.
.RE

.LP
.B
ir(Module, Name, Arity) -> ok | {error, function_not_found} 
.br
.RS
.LP
Types:

.RS 3
Module = Name = atom()
.br
Arity = int()
.br
.RE
.RE
.RS
.LP
Deletes the breakpoints at the first line of every clause of function \fIModule:Name/Arity\fR\&\&.
.RE

.LP
.B
ibd(Module, Line) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
.RE
.RE
.RS
.LP
Makes the breakpoint at \fILine\fR\& in \fIModule\fR\& inactive\&.
.RE

.LP
.B
ibe(Module, Line) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
.RE
.RE
.RS
.LP
Makes the breakpoint at \fILine\fR\& in \fIModule\fR\& active\&.
.RE

.LP
.B
iba(Module, Line, Action) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
Action = enable | disable | delete
.br
.RE
.RE
.RS
.LP
Sets the trigger action of the breakpoint at \fILine\fR\& in \fIModule\fR\& to \fIAction\fR\&\&.
.RE

.LP
.B
ibc(Module, Line, Function) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
Line = int()
.br
Function = {Module,Name}
.br
 Name = atom()
.br
.RE
.RE
.RS
.LP
Sets the conditional test of the breakpoint at \fILine\fR\& in \fIModule\fR\& to \fIFunction\fR\&\&.
.LP
The conditional test is performed by calling \fIModule:Name(Bindings)\fR\&, where \fIBindings\fR\& is the current variable bindings\&. The function must return \fItrue\fR\& (break) or \fIfalse\fR\& (do not break)\&. To retrieve the value of a variable \fIVar\fR\&, use int:get_binding(Var, Bindings)\&.
.RE

.LP
.B
ipb() -> ok
.br
.RS
.LP
Prints all existing breakpoints\&.
.RE

.LP
.B
ipb(Module) -> ok
.br
.RS
.LP
Types:

.RS 3
Module = atom()
.br
.RE
.RE
.RS
.LP
Prints all existing breakpoints in \fIModule\fR\&\&.
.RE

.LP
.B
iv() -> atom()
.br
.RS
.LP
Returns the current version number of the interpreter\&. Same as the version number of the Debugger application\&.
.RE

.LP
.B
help() -> ok
.br
.RS
.LP
Prints help text\&.
.RE

.SH "SEE ALSO"

.LP
\fIint(3erl)\fR\&