Perl5 リファレンス

       caller EXPR

       caller  Returns the context of the current subroutine
               call.  In scalar context, returns the caller's
               package name if there is a caller, that is, if
               we're in a subroutine or `eval' or `require', and
               the undefined value otherwise.  In list context,

                   ($package, $filename, $line) = caller;

               With EXPR, it returns some extra information that
               the debugger uses to print a stack trace.  The
               value of EXPR indicates how many call frames to go
               back before the current one.

                   ($package, $filename, $line, $subroutine, $hasargs,
                   $wantarray, $evaltext, $is_require, $hints, $bitmask) = caller($i);

               Here $subroutine may be `(eval)' if the frame is
               not a subroutine call, but an `eval'.  In such a
               case additional elements $evaltext and
               `$is_require' are set: `$is_require' is true if
               the frame is created by a `require' or `use'
               statement, $evaltext contains the text of the
               `eval EXPR' statement.  In particular, for a `eval
               BLOCK' statement, $filename is `(eval)', but
               $evaltext is undefined.  (Note also that each
               `use' statement creates a `require' frame inside
               an `eval EXPR') frame.  `$hints' and `$bitmask'
               contain pragmatic hints that the caller was
               compiled with.  The `$hints' and `$bitmask' values
               are subject to change between versions of Perl,
               and are not meant for external use.

               Furthermore, when called from within the DB
               package, caller returns more detailed information:
               it sets the list variable `@DB::args' to be the
               arguments with which the subroutine was invoked.

               Be aware that the optimizer might have optimized
               call frames away before `caller' had a chance to
               get the information.  That means that `caller(N)'
               might not return information about the call frame
               you expect it do, for `N > 1'.  In particular,
               `@DB::args' might have information from the
               previous time `caller' was called.