i(3)

📦
version 29.0.6 · 2 versions
, in nixos 26.05, nixpkgs unstable, ubuntu stonking

✨ NAME ✨

i — Debugger/Interpreter Interface 💖 (the little module with the tiny name and the big main-character energy, fr fr)

🦋 DESCRIPTION 🦋

Okay bestie so the i module is basically the short-form era of the graphical Debugger 👑 — it hands you cute lil abbreviations for a bunch of the functions the Debugger uses, plus some of the functions living over in module int, the Erlang interpreter.

On top of that, this module also gives you the hookup for displaying status info about interpreted processes and breakpoints. Very "let me check in on my processes" of it 💅

And here's the slay part: you can attach to interpreted processes by only handing over the corresponding process identity. By default, an attachment window pops up for you ✨. Processes sitting on other Erlang nodes can be attached either manually or automatically — your choice, no pressure 🫶.

Now, the functions in this module are defined in the Erlang shell. That means you can call them without the i: prefix. Like:

1> ii(t).
{module,t}
2> iaa([init]).
true

periodt 💫

🌈 FUNCTIONS 🌈

help() -> ok.

Prints help for using the functions in this module. Your lil instruction manual moment 🎀

ia(Pid) -> ok | no_proc when Pid :: pid().

ia(Pid) -> ok | no_proc when Pid :: pid().

Attaches to the debugged process Pid 🫶

An "Attach Process" window is opened for the process.

ia(Pid, Function) -> ok | no_proc

ia(Pid, Function) -> ok | no_proc
            when
                Pid :: pid(),
                Function :: {Module, Name},
                Module :: module(),
                Name :: atom().

Attaches to the debugged process Pid 💖

The interpreter calls spawn(Module, Name, [Pid]) (and ignores the result). Yeah, it just spawns and moves on, no cap 😌

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

ia(X, Y, Z) -> ok | no_proc
            when X :: integer(), Y :: integer(), Z :: integer().

Equivalent to ia(Pid), where Pid is the result of calling the shell function pid(X, Y, Z). Same vibe, different entry point ✨

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

ia(X, Y, Z, Function) -> ok | no_proc
            when
                X :: integer(),
                Y :: integer(),
                Z :: integer(),
                Function :: {Module, Name},
                Module :: module(),
                Name :: atom().

Equivalent to 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 🦋

lowkey important: that function is unofficial, so don't come for me if you lean on it too hard 🙈

iaa(Flags) -> true

iaa(Flags) -> true when Flags :: [init | break | exit].

Sets when to attach to a debugged process automatically 🔥

Debugger supplies a function that opens "Attach Process" window for the process.

See int:auto_attach/2 for more information.

iaa(Flags, Function) -> true

iaa(Flags, Function) -> true
            when
                Flags :: [init | break | exit],
                Function :: {Module, Name, Args},
                Module :: module(),
                Name :: atom(),
                Args :: [term()].

Sets when and how to attach to a debugged process automatically 💅

See int:auto_attach/2 for more information.

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

ib(Module, Line) -> ok | {error, break_exists}
            when Module :: module(), Line :: integer().

Creates a breakpoint at Line in Module ⭐

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

ib(Module, Name, Arity) -> ok | {error, function_not_found}
            when Module :: module(), Name :: atom(), Arity :: integer().

Creates breakpoints at the first line of every clause of function Module:Name/Arity. All of them. Not one, not two, all of them 👑

iba(Module, Line, Action) -> ok

iba(Module, Line, Action) -> ok
            when
                Module :: module(),
                Line :: integer(),
                Action :: enable | disable | delete.

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

ibc(Module, Line, Function) -> ok

ibc(Module, Line, Function) -> ok
            when
                Module :: module(),
                Line :: integer(),
                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) 💫

ibd(Module, Line) -> ok

ibd(Module, Line) -> ok when Module :: module(), Line :: integer().

Makes the breakpoint at Line in Module inactive 😴 (breakpoint is on do-not-disturb)

ibe(Module, Line) -> ok

ibe(Module, Line) -> ok when Module :: module(), Line :: integer().

Makes the breakpoint at Line in Module active 🚨 (breakpoint is back and thriving)

ic() -> ok.

Clears information about processes executing interpreted code by removing all information about terminated processes. Spring cleaning era 🧹✨

ii(AbsModules | AbsModule) -> Result

ii(AbsModules | AbsModule) -> Result
            when
                AbsModules :: [AbsModule, ...],
                AbsModule :: Module | File,
                Module :: module(),
                File :: file:name_all(),
                Result :: AbsModuleResult | AbsModulesResult,
                AbsModuleResult :: {module, Module} | error,
                AbsModulesResult :: ok.

Interprets the specified module(s) on the local node 💖

  • If AbsModule :: Module | File, then Result :: {module, Module} | error.
  • If AbsModules :: [AbsModule], then Result :: ok.

See int:i/1 for more information.

il() -> ok.

Makes a printout of all interpreted modules 📋

Modules are printed together with the full path name of the corresponding source code file. Recipts included, bestie ✨

im() -> pid().

Starts a new graphical Monitor window 🪟

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. It's giving main window energy 🌟

ini(AbsModules | AbsModule) -> Result

ini(AbsModules | AbsModule) -> Result
            when
                AbsModules :: [AbsModule],
                AbsModule :: Module | File,
                Module :: module(),
                File :: file:name_all(),
                Result :: AbsModuleResult | AbsModulesResult,
                AbsModuleResult :: {module, Module} | error,
                AbsModulesResult :: ok.

Interprets the specified module(s) on all known nodes 🌈

  • If AbsModule :: Module | File, then Result :: {module, Module} | error.
  • If AbsModules :: [AbsModule], then Result :: ok.

See int:ni/1 for more information.

inq(AbsModule) -> ok

inq(AbsModule) -> ok
            when
                AbsModule :: Module | File,
                Module :: module(),
                File :: file:name_all().

Stops interpreting the specified module on all known nodes 🛑

ip() -> ok.

Prints the current status of all interpreted processes 📊 bestie is doing a vibe check on every process rn

ipb() -> ok.

Prints all existing breakpoints 🔍

ipb(Module) -> ok

ipb(Module) -> ok when Module :: module().

Prints all existing breakpoints in Module 🔎

iq(AbsModule) -> ok

iq(AbsModule) -> ok
            when
                AbsModule :: Module | File,
                Module :: module(),
                File :: file:name_all().

Stops interpreting the specified module on the local node 🚫

ir() -> ok.

Deletes all breakpoints in all interpreted modules. Clean slate, fresh start 💅✨

ir(Module) -> ok

ir(Module) -> ok when Module :: module().

Deletes all breakpoints in Module 🧹

ir(Module, Line) -> ok

ir(Module, Line) -> ok when Module :: module(), Line :: integer().

Deletes the breakpoint at Line in Module 🗑️

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

ir(Module, Name, Arity) -> ok | {error, function_not_found}
            when Module :: module(), Name :: atom(), Arity :: integer().

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

ist(Flag) -> true

ist(Flag) -> true when Flag :: all | no_tail | false.

Sets how to save call frames in the stack 🥞

See int:stack_trace/1 for more information.

iv() -> atom().

Returns the current version of the interpreter (Debugger) 🏷️ (and yes it's an atom, she's classy like that)

okay bye bestie, go forth and breakpoint responsibly 🫶💖

— mwah, this page was brought to you by Ericsson AB, serving up debugger 7.0, section i(3) 🌸✨

📦 where this page comes from