[Ericsson AB]

int

MODULE

int

MODULE SUMMARY

Interpreter Interface.

DESCRIPTION

The Erlang interpreter provides mechanisms for breakpoints and stepwise execution of code. It is mainly intended to be used by the Debugger, see Debugger User's Guide and debugger(3).

From the shell, it is possible to:

By attaching to a process executing interpreted code, it is possible to examine variable bindings and order stepwise execution. This is done by sending and receiving information to/from the process via a third process, called the meta process. It is possible, but not recommended, to implement your own attached process. See int.erl for available functions and dbg_ui_trace.erl for possible messages.

Breakpoints

Breakpoints are specified on a line basis. When a process executing code in an interpreted module reaches a breakpoint, it will stop. This means that that a breakpoint must be set at an executable line, i.e. a line of code containing an executable expression.

A breakpoint have a status, a trigger action and may have a condition associated with it. The status is either active or inactive. An inactive breakpoint is ignored. When a breakpoint is reached, the trigger action specifies if the breakpoint should continue to be active (enable), if it should become inactive (disable), or if it should be removed (delete). A condition is a tuple {Module,Name}. When the breakpoint is reached, Module:Name(Bindings) is called. If this evaluates to true, execution will stop. If this evaluates to false, the breakpoint is ignored. Bindings contains the current variable bindings, use get_binding to retrieve the value for a given variable.

By default, a breakpoint is active, has trigger action enable and has no condition associated with it. For more detailed information about breakpoints, refer to Debugger User's Guide.

EXPORTS

i(AbsModule) -> {module,Module} | error
ni(AbsModule) -> {module,Module} | error

Types:

AbsModule = Module | File | [Module | File]
 Module = atom()
 File = string()
Options = term()

Interprets the specified module. i/1,2 interprets the module only at the current node. ni/1,2 interprets the module at all known nodes.

A module may be given by its module name (atom) or by its file name. If given by its module name, the object code Module.beam is searched for in the current path. The source code Module.erl is searched for first in the same directory as the object code, then in a src directory next to it.

If given by its file name, the file name may include a path and the .erl extension may be omitted. The object code Module.beam is searched for first in the same directory as the source code, then in an ebin directory next to it, and then in the current path.

Note!

The interpreter needs both the source code and the object code, and the object code must include debug information. That is, only modules compiled with the option debug_info set can be interpreted.

n(AbsModule) -> ok
nn(AbsModule) -> ok

Types:

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

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

As for i/1 and ni/1, a module may be given by either its module name or its file name.

interpreted() -> [Module]

Types:

Module = atom()

Returns a list with all interpreted modules.

file(Module) -> File | {error,not_loaded}

Types:

Module = atom()
File = string()

Returns the source code file name File for an interpreted module Module.

interpretable(AbsModule) -> true | {error,Reason}

Types:

AbsModule = Module | File
 Module = atom()
 File = string()
Reason = no_src | no_beam | no_debug_info | badarg

Checks if a module is possible to interpret. The module can be given by its module name Module or its file name File.

The function returns true if both source code and object code for the module is found, and the module has been compiled with the option debug_info set.

The function returns {error,Reason} where Reason is no_src if no source code is found, no_beam if no object code is found, no_debug_info if the module has not been compiled with the option debug_info set, or badarg if AbsModule does not exist.

auto_attach() -> false | {Flags,Function}
auto_attach(false)
auto_attach(Flags, Function)

Types:

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

Get and set when and how to automatically attach to a process executing code in interpreted modules. false means never attach, this is the default. Otherwise automatic attach is defined by a list of flags and a function. The following flags may be specified:

When the specified event occurs, the function Function will be called as:

spawn(Module, Name, [Pid | Args])
        

The resulting process can attach to, i.e. send commands to and receive messages from, the interpreted process, see above.

stack_trace() -> Flag
stack_trace(Flag)

Types:

Flag = all | no_tail | false

Get and set how to save call frames in the stack. This makes it possible to inspect the call chain of a process.

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

Types:

Module = atom()
Line = integer()

Creates a breakpoint at Line in Module.

delete_break(Module, Line) -> ok

Types:

Module = atom()
Line = integer()

Deletes the breakpoint located at Line in Module.

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

Types:

Module = Name = atom()
Function = atom()
Arity = integer()

Create a breakpoint at the first line of every clause of the Module:Function/Arity function.

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

Types:

Module = Name = atom()
Arity = integer()

Delete the breakpoints at the first line of every clause of the Module:Function/Arity function.

no_break() -> ok
no_break(Module) -> ok

Deletes all breakpoints, or all breakpoints in Module.

disable_break(Module, Line) -> ok

Types:

Module = atom()
Line = integer()

Makes the breakpoint at Line in Module inactive.

enable_break(Module, Line) -> ok

Types:

Module = atom()
Line = integer()

Makes the breakpoint at Line in Module active.

action_at_break(Module, Line, Action) -> ok

Types:

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

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

test_at_break(Module, Line, Function) -> ok

Types:

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

Set the condition of the breakpoint at Line in Module to Function.

get_binding(Var, Bindings) -> {value,Value} | unbound

Types:

Var = atom()
Bindings = term()
Value = term()

Retrieve the binding of Variable. This function is intended to be used by a breakpoint condition function.

all_breaks() -> [Break]
all_breaks(Module) -> [Break]

Types:

Break = {Point,Options}
 Point = {Module,Line}
  Module = atom()
  Line = int()
 Options = [Status,Trigger,null,Cond|]
  Status = active | inactive
  Trigger = enable | disable | delete
  Cond = null | Function
   Function = {Module,Name}
    Name = atom()

Gets all breakpoints, or all breakpoints in Module.

snapshot() -> [Snapshot]

Types:

Snapshot = {Pid, Function, Status, Info}
 Pid = pid()
 Function = {Module,Name,Args}
  Module = Name = atom()
  Args = [term()]
 Status = idle | running | waiting | break | exit | no_conn
 Info = {} | {Module,Line} | ExitReason
  Line = integer()
  ExitReason = term()

Gets information about all processes executing interpreted code.

Status is one of:

clear() -> ok

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

continue(Pid) -> ok | {error,not_interpreted}
continue(X,Y,Z) -> ok | {error,not_interpreted}

Types:

Pid = pid()
X = Y = Z = integer()

Resume process execution for Pid, or for c:pid(X,Y,Z).

AUTHORS

Gunilla Arendt - support@erlang.ericsson.se

debugger 2.3.3
Copyright © 1991-2005 Ericsson AB