table of contents
other versions
- jessie 1:17.3-dfsg-4+deb8u2
- jessie-backports 1:19.2.1+dfsg-2+deb9u1~bpo8+1
- stretch 1:19.2.1+dfsg-2+deb9u2
- testing 1:21.2.5+dfsg-1
- unstable 1:21.2.6+dfsg-1
- experimental 1:22.0~rc1+dfsg-1
int(3erl) | Erlang Module Definition | int(3erl) |
NAME¶
int - Interpreter InterfaceDESCRIPTION¶
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(3erl). From the shell, it is possible to:- *
- Specify which modules should be interpreted.
- *
- Specify breakpoints.
- *
- Monitor the current status of all processes executing code in interpreted modules, also processes at other Erlang nodes.
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, that is, 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
Types:
AbsModules = [AbsModule]
AbsModule = Module | File | [Module | File]
Module = atom()
File = string()
Module = atom()
File = string()
Interprets the specified module(s). i/1 interprets the module only at the
current node. ni/1 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.
n(AbsModule) -> ok
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.
The functions returns {module,Module} if the module was interpreted, or
error if it was not.
The argument may also be a list of modules/file names, in which case the
function tries to interpret each module as specified above. The function then
always returns ok, but prints some information to stdout if a module
could not be interpreted.
Types:
AbsModule = Module | File | [Module | File]
Module = atom()
File = string()
Module = atom()
File = string()
Stops interpreting the specified module. n/1 stops interpreting the
module 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 | {app,App}
App = atom()
Module = atom()
File = string()
App = atom()
Checks if a module is possible to interpret. The module can be given by its
module name Module or its source file name File. If given by a
module name, the module is searched for in the code path.
The function returns true if both source code and object code for the
module is found, the module has been compiled with the option
debug_info set and does not belong to any of the applications Kernel,
STDLIB, GS or Debugger itself.
The function returns {error,Reason} if the module for some reason is not
possible to interpret.
Reason is no_src if no source code is found or no_beam if
no object code is found. It is assumed that the source- and object code are
located either in the same directory, or in src and ebin
directories next to each other.
Reason is no_debug_info if the module has not been compiled with
the option debug_info set.
Reason is badarg if AbsModule is not found. This could be
because the specified file does not exist, or because code:which/1 does
not return a beam file name, which is the case not only for non-existing
modules but also for modules which are preloaded or cover compiled.
Reason is {app,App} where App is kernel,
stdlib, gs or debugger if AbsModule belongs to one
of these applications.
Note that the function can return true for a module which in fact is not
interpretable in the case where the module is marked as sticky or resides in a
directory marked as sticky, as this is not discovered until the interpreter
actually tries to load the module.
auto_attach() -> false | {Flags,Function}
Types:
Flags = [init | break | exit]
Function = {Module,Name,Args}
Module = Name = atom()
Args = [term()]
Module = Name = atom()
Args = [term()]
Gets and sets when and how to automatically attach to a process executing code
in interpreted modules. false means never automatically 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:
stack_trace() -> Flag
- *
- init - attach when a process for the very first time calls an interpreted function.
- *
- break - attach whenever a process reaches a breakpoint.
- *
- exit - attach when a process terminates.
spawn(Module, Name, [Pid | Args])Pid is the pid of the process executing interpreted code.
Types:
Flag = all | no_tail | false
Gets and sets how to save call frames in the stack. Saving call frames makes it
possible to inspect the call chain of a process, and is also used to emulate
the stack trace if an error (an exception of class error) occurs.
break(Module, Line) -> ok | {error,break_exists}
- *
- all - save information about all current calls, that is, function calls that have not yet returned a value.
- *
- no_tail - save information about current calls, but discard previous information when a tail recursive call is made. This option consumes less memory and may be necessary to use for processes with long lifetimes and many tail recursive calls. This is the default.
- *
- false - do not save any information about current calls.
Types:
Module = atom()
Line = int()
Creates a breakpoint at Line in Module.
delete_break(Module, Line) -> ok
Types:
Module = atom()
Line = int()
Deletes the breakpoint located at Line in Module.
break_in(Module, Name, Arity) -> ok | {error,function_not_found}
Types:
Module = Name = atom()
Arity = int()
Creates a breakpoint at the first line of every clause of the
Module:Name/Arity function.
del_break_in(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 the
Module:Name/Arity function.
no_break() -> ok
Deletes all breakpoints, or all breakpoints in Module.
disable_break(Module, Line) -> ok
Types:
Module = atom()
Line = int()
Makes the breakpoint at Line in Module inactive.
enable_break(Module, Line) -> ok
Types:
Module = atom()
Line = int()
Makes the breakpoint at Line in Module active.
action_at_break(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.
test_at_break(Module, Line, Function) -> ok
Types:
Module = atom()
Line = int()
Function = {Module,Name}
Name = atom()
Name = atom()
Sets the conditional test of the breakpoint at Line in Module to
Function. The function must fulfill the requirements specified in the
section Breakpoints above.
get_binding(Var, Bindings) -> {value,Value} | unbound
Types:
Var = atom()
Bindings = term()
Value = term()
Retrieves the binding of Var. This function is intended to be used by the
conditional function of a breakpoint.
all_breaks() -> [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()
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 = int()
ExitReason = term()
Pid = pid()
Function = {Module,Name,Args}
Module = Name = atom()
Args = [term()]
Status = idle | running | waiting | break | exit | no_conn
Info = {} | {Module,Line} | ExitReason
Line = int()
ExitReason = term()
Gets information about all processes executing interpreted code.
Status is one of:
clear() -> ok
- *
- Pid - process identifier.
- *
- Function - first interpreted function called by the process.
- *
- Status - current status of the process.
- *
- Info - additional information.
- *
- idle - the process is no longer executing interpreted code. Info={}.
- *
- running - the process is running. Info={}.
- *
- waiting - the process is waiting at a receive. Info={}.
- *
- break - process execution has been stopped, normally at a breakpoint. Info={Module,Line}.
- *
- exit - the process has terminated. Info=ExitReason.
- *
- no_conn - the connection is down to the node where the process is running. Info={}.
Clears information about processes executing interpreted code by removing all
information about terminated processes.
continue(Pid) -> ok | {error,not_interpreted}
Types:
Pid = pid()
X = Y = Z = int()
Resume process execution for Pid, or for c:pid(X,Y,Z).
debugger 4.0.1 | Ericsson AB |