NAME

       i - Debugger/Interpreter Interface.

DESCRIPTION

       The i module provides short forms for some of the functions used by the graphical Debugger
       and some of the functions in module int, the Erlang interpreter.

       This module also provides facilities for displaying status information  about  interpreted
       processes and break points.

       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.

       By  preference,  these functions can be included in module shell_default. By default, they
       are included in that module.

EXPORTS

       im() -> pid()

              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.

       ii(AbsModules) -> ok
       ii(AbsModule) -> {module, Module} | error
       ini(AbsModules) -> ok
       ini(AbsModule) -> {module, Module} | error

              Types:

                 AbsModules = [AbsModule]
                 AbsModule = Module | File
                  Module = atom()
                  File = string()

              Interprets  the  specified  module(s).  ii/1  interprets  the module(s) only at the
              current node, see int:i/1. ini/1 interprets the module(s) at all known  nodes,  see
              int:ni/1.

       iq(AbsModule) -> ok
       inq(AbsModule) -> ok

              Types:

                 AbsModule = Module | File
                  Module = atom()
                  File = string()

              Stops interpreting the specified module. iq/1 stops interpreting the module only at
              the current node. inq/1 stops interpreting the module at all known nodes.

       il() -> ok

              Makes a printout of all interpreted modules. Modules are printed together with  the
              full path name of the corresponding source code file.

       ip() -> ok

              Prints the current status of all interpreted processes.

       ic() -> ok

              Clears  information  about  processes  executing  interpreted  code by removing all
              information about terminated processes.

       iaa(Flags) -> true
       iaa(Flags, Function) -> true

              Types:

                 Flags = [init | break | exit]
                 Function = {Module,Name,Args}
                  Module = Name = atom()
                  Args = [term()]

              Sets  when  and  how  to  attach  to  a   debugged   process   automatically,   see
              int:auto_attach/2. Function defaults to the standard function used by Debugger.

       ist(Flag) -> true

              Types:

                 Flag = all | no_tail | false

              Sets how to save call frames in the stack, see int:stack_trace/1.

       ia(Pid) -> ok | no_proc

              Types:

                 Pid = pid()

              Attaches  to  the  debugged process Pid. An Attach Process window is opened for the
              process.

       ia(X,Y,Z) -> ok | no_proc

              Types:

                 X = Y = Z = int()

              Same as ia(Pid), where Pid is the result of calling the shell function pid(X,Y,Z).

       ia(Pid, Function) -> ok | no_proc

              Types:

                 Pid = pid()
                 Function = {Module,Name}
                  Module = Name = atom()

              Attaches to the debugged process Pid. The  interpreter  calls  spawn(Module,  Name,
              [Pid]) (and ignores the result).

       ia(X,Y,Z, Function) -> ok | no_proc

              Types:

                 X = Y = Z = int()
                 Function = {Module,Name}
                  Module = Name = atom()

              Same  as  ia(Pid,  Function), where Pid is the result of calling the shell function
              pid(X,Y,Z). An attached  process  is  expected  to  call  the  unofficial  function
              int:attached(Pid)  and  to  be able to handle messages from the interpreter. For an
              example, see dbg_wx_trace.erl.

       ib(Module, Line) -> ok | {error, break_exists}

              Types:

                 Module = atom()
                 Line = int()

              Creates a breakpoint at Line in Module.

       ib(Module, Name, Arity) -> ok | {error, function_not_found}

              Types:

                 Module = Name = atom()
                 Arity = int()

              Creates  breakpoints  at   the   first   line   of   every   clause   of   function
              Module:Name/Arity.

       ir() -> ok

              Deletes all breakpoints.

       ir(Module) -> ok

              Types:

                 Module = atom()

              Deletes all breakpoints in Module.

       ir(Module, Line) -> ok

              Types:

                 Module = atom()
                 Line = int()

              Deletes the breakpoint at Line in Module.

       ir(Module, Name, Arity) -> ok | {error, function_not_found}

              Types:

                 Module = Name = atom()
                 Arity = int()

              Deletes   the   breakpoints   at  the  first  line  of  every  clause  of  function
              Module:Name/Arity.

       ibd(Module, Line) -> ok

              Types:

                 Module = atom()
                 Line = int()

              Makes the breakpoint at Line in Module inactive.

       ibe(Module, Line) -> ok

              Types:

                 Module = atom()
                 Line = int()

              Makes the breakpoint at Line in Module active.

       iba(Module, Line, Action) -> ok

              Types:

                 Module = atom()
                 Line = int()
                 Action = enable | disable | delete

              Sets the trigger action of the breakpoint at Line in Module to Action.

       ibc(Module, Line, Function) -> ok

              Types:

                 Module = atom()
                 Line = int()
                 Function = {Module,Name}
                  Name = atom()

              Sets the conditional test of the breakpoint at Line in Module to Function.

              The conditional test is performed by calling Module:Name(Bindings), where  Bindings
              is  the  current  variable bindings. The function must return true (break) or false
              (do not break). To retrieve the value of a variable Var,  use  int:get_binding(Var,
              Bindings).

       ipb() -> ok

              Prints all existing breakpoints.

       ipb(Module) -> ok

              Types:

                 Module = atom()

              Prints all existing breakpoints in Module.

       iv() -> atom()

              Returns  the  current version number of the interpreter. Same as the version number
              of the Debugger application.

       help() -> ok

              Prints help text.

SEE ALSO

       int(3erl)