i(3erl) - f39

1i(3)                       Erlang Module Definition                       i(3)
2
3
4

NAME

6       i - Debugger/Interpreter Interface.
7

DESCRIPTION

9       The i module provides short forms for some of the functions used by the
10       graphical Debugger and some of the functions in module int, the  Erlang
11       interpreter.
12
13       This  module also provides facilities for displaying status information
14       about interpreted processes and break points.
15
16       It is possible to attach to interpreted processes by giving the  corre‐
17       sponding  process  identity  only.  By default, an attachment window is
18       displayed. Processes at other Erlang nodes can be attached manually  or
19       automatically.
20
21       By preference, these functions can be included in module shell_default.
22       By default, they are included in that module.
23

EXPORTS

25       im() -> pid()
26
27              Starts a new graphical monitor. This is the Monitor window,  the
28              main  window of Debugger. All the Debugger and interpreter func‐
29              tionality is accessed from the Monitor window. This window  dis‐
30              plays  the status of all processes that have been or are execut‐
31              ing interpreted modules.
32
33       ii(AbsModules) -> ok
34       ii(AbsModule) -> {module, Module} | error
35       ini(AbsModules) -> ok
36       ini(AbsModule) -> {module, Module} | error
37
38              Types:
39
40                 AbsModules = [AbsModule]
41                 AbsModule = Module | File
42                  Module = atom()
43                  File = string()
44
45              Interprets the specified module(s).  ii/1  interprets  the  mod‐
46              ule(s)  only  at the current node, see int:i/1. ini/1 interprets
47              the module(s) at all known nodes, see int:ni/1.
48
49       iq(AbsModule) -> ok
50       inq(AbsModule) -> ok
51
52              Types:
53
54                 AbsModule = Module | File
55                  Module = atom()
56                  File = string()
57
58              Stops interpreting the specified module. iq/1 stops interpreting
59              the  module  only  at the current node. inq/1 stops interpreting
60              the module at all known nodes.
61
62       il() -> ok
63
64              Makes a printout of all interpreted modules. Modules are printed
65              together  with  the  full  path name of the corresponding source
66              code file.
67
68       ip() -> ok
69
70              Prints the current status of all interpreted processes.
71
72       ic() -> ok
73
74              Clears information about processes executing interpreted code by
75              removing all information about terminated processes.
76
77       iaa(Flags) -> true
78       iaa(Flags, Function) -> true
79
80              Types:
81
82                 Flags = [init | break | exit]
83                 Function = {Module,Name,Args}
84                  Module = Name = atom()
85                  Args = [term()]
86
87              Sets when and how to attach to a debugged process automatically,
88              see int:auto_attach/2. Function defaults to the  standard  func‐
89              tion used by Debugger.
90
91       ist(Flag) -> true
92
93              Types:
94
95                 Flag = all | no_tail | false
96
97              Sets   how   to   save   call   frames   in   the   stack,   see
98              int:stack_trace/1.
99
100       ia(Pid) -> ok | no_proc
101
102              Types:
103
104                 Pid = pid()
105
106              Attaches to the debugged process Pid. An Attach  Process  window
107              is opened for the process.
108
109       ia(X,Y,Z) -> ok | no_proc
110
111              Types:
112
113                 X = Y = Z = int()
114
115              Same  as  ia(Pid),  where Pid is the result of calling the shell
116              function pid(X,Y,Z).
117
118       ia(Pid, Function) -> ok | no_proc
119
120              Types:
121
122                 Pid = pid()
123                 Function = {Module,Name}
124                  Module = Name = atom()
125
126              Attaches to the debugged  process  Pid.  The  interpreter  calls
127              spawn(Module, Name, [Pid]) (and ignores the result).
128
129       ia(X,Y,Z, Function) -> ok | no_proc
130
131              Types:
132
133                 X = Y = Z = int()
134                 Function = {Module,Name}
135                  Module = Name = atom()
136
137              Same  as  ia(Pid,  Function), where Pid is the result of calling
138              the shell function pid(X,Y,Z). An attached process  is  expected
139              to call the unofficial function int:attached(Pid) and to be able
140              to handle messages from the interpreter.  For  an  example,  see
141              dbg_wx_trace.erl.
142
143       ib(Module, Line) -> ok | {error, break_exists}
144
145              Types:
146
147                 Module = atom()
148                 Line = int()
149
150              Creates a breakpoint at Line in Module.
151
152       ib(Module, Name, Arity) -> ok | {error, function_not_found}
153
154              Types:
155
156                 Module = Name = atom()
157                 Arity = int()
158
159              Creates  breakpoints  at the first line of every clause of func‐
160              tion Module:Name/Arity.
161
162       ir() -> ok
163
164              Deletes all breakpoints.
165
166       ir(Module) -> ok
167
168              Types:
169
170                 Module = atom()
171
172              Deletes all breakpoints in Module.
173
174       ir(Module, Line) -> ok
175
176              Types:
177
178                 Module = atom()
179                 Line = int()
180
181              Deletes the breakpoint at Line in Module.
182
183       ir(Module, Name, Arity) -> ok | {error, function_not_found}
184
185              Types:
186
187                 Module = Name = atom()
188                 Arity = int()
189
190              Deletes the breakpoints at the first line  of  every  clause  of
191              function Module:Name/Arity.
192
193       ibd(Module, Line) -> ok
194
195              Types:
196
197                 Module = atom()
198                 Line = int()
199
200              Makes the breakpoint at Line in Module inactive.
201
202       ibe(Module, Line) -> ok
203
204              Types:
205
206                 Module = atom()
207                 Line = int()
208
209              Makes the breakpoint at Line in Module active.
210
211       iba(Module, Line, Action) -> ok
212
213              Types:
214
215                 Module = atom()
216                 Line = int()
217                 Action = enable | disable | delete
218
219              Sets  the  trigger action of the breakpoint at Line in Module to
220              Action.
221
222       ibc(Module, Line, Function) -> ok
223
224              Types:
225
226                 Module = atom()
227                 Line = int()
228                 Function = {Module,Name}
229                  Name = atom()
230
231              Sets the conditional test of the breakpoint at Line in Module to
232              Function.
233
234              The  conditional  test is performed by calling Module:Name(Bind‐
235              ings), where Bindings is  the  current  variable  bindings.  The
236              function  must  return  true (break) or false (do not break). To
237              retrieve the value of a variable Var,  use  int:get_binding(Var,
238              Bindings).
239
240       ipb() -> ok
241
242              Prints all existing breakpoints.
243
244       ipb(Module) -> ok
245
246              Types:
247
248                 Module = atom()
249
250              Prints all existing breakpoints in Module.
251
252       iv() -> atom()
253
254              Returns  the  current version number of the interpreter. Same as
255              the version number of the Debugger application.
256
257       help() -> ok
258
259              Prints help text.
260

NAME

DESCRIPTION

EXPORTS

SEE ALSO