class CallFrame
Captures the current frame state
A CallFrame will be usually captured from the current state of a program using the callframe subroutine.
my = callframe;say "The above line of code ran at :.";
With no arguments the callframe will give you frame information for the line calling callframe
. The file and line annotations will be identical to those in $?FILE
and $?LINE
.
You may, however, pass a number to callframe
to specify a different frame level. A positive number will move upward through the levels of frame. A negative number will move downward into the callframe
method and class itself at the point at which they are running to construct this information for you.
The frames themselves do not necessarily match only method or subroutine calls. Perl constructs a frames for blocks and such as well, so if you need a callframe for a particular method call, do not assume it is a fixed number of levels up.
Each frame stores annotations, including the file and line annotations, which have convenience methods for accessing them directly. You can also retrieve a reference to the code block of the currently executing frame using the code method. The frame also captures all lexical variables stored with the frame, which are available by calling my on the frame object.
Here's a short example that will find the calling routine and print the package of the caller using the callframe
interface.
sub calling-frame()calling-frame;
If you just need to trace caller information, Backtrace may provide a better means of getting it. CallFrame contains more information about a specific frame, but provides a tedious interface for enumerating a call stack.
Methods
Note From version 6.d, .perl
can be called on CallFrame
.
method code
method code()
Return the callable code for the current block. When called on the object returned by callframe(0)
, this will be the same value found in &?BLOCK
.
my ;for ^3 ;say .code()
The $frame
variable will hold the Code
for the block inside the loop in this case.
method file
method file()
This is a shortcut for looking up the file
annotation. Therefore, the following code prints True
.
my = callframe(0);say .file eq .annotations<file>;
method line
method line()
This is a shortcut for looking up the line
annotation. For example, the following two calls are identical.
say callframe(1).line;say callframe(1).annotations<line>;
method annotations
method annotations()
Returns a Map containing the invocants annotations, i.e. line
and file
. An easier way to get hold of the annotation information is to use one of the convenience methods instead.
say callframe.annotations.^name; # OUTPUT: «Map»say callframe.annotations<file> eq callframe.file; # OUTPUT: «True»
method my
method my()
Return a Hash that names all the variables and their values associated with the lexical scope of the frame.
sub some-valuemy = some-value();say .my<$the-answer>; # OUTPUT: «42»
Routines
sub callframe
sub callframe(Int = 0)
Returns a CallFrame object for the given level. If no level is given, the default level is 0. Positive levels move up the frame stack and negative levels move down (into the call to callframe
and deeper).
Returns Mu if there is no call information for the given level. Negative levels may result in an exception.