Caller works well enough except for AUTOLOAD.

#!/usr/bin/env perl
use strict;
use warnings;

sub foo {
    my $name = (caller(0))[3];
    my $caller = (caller(1))[3];
    if ( defined $caller )
    {
        print "My name is $name and I was called by $caller.\n";
    }
    else
    {
        print "My name is $name.\n";
    }
}

sub bar {
    my $name = (caller(0))[3];
    my $caller = (caller(1))[3];
    if ( defined $caller )
    {
        print "My name is $name and I was called by $caller.\n";
    }
    else
    {
        print "My name is $name.\n";
    }
    foo();
    baz();
}

sub AUTOLOAD {
    my $name = (caller(0))[3];
    my $called = our $AUTOLOAD;
    my $caller = (caller(1))[3];
    if ( defined $caller )
    {
        print "My name is $name and I was called as $called by $caller
+.\n";
    }
    else
    {
        print "My name is $name and I was called as $called.\n";
    }
}

foo();
bar();
baz();
__END__
My name is main::foo.
My name is main::bar.
My name is main::foo and I was called by main::bar.
My name is main::AUTOLOAD and I was called as main::baz by main::bar.
My name is main::AUTOLOAD and I was called as main::baz.
[download]

Updated to show who called (if applicable).

This is why I think that the best way of implementing AUTOLOAD is something like this:

use Sub::Name;

sub AUTOLOAD {
   my ($name) = (our $AUTOLOAD =~ /(\w+)$/);
   my $func = subname $name => sub {
      ...;  # this is where the work happens
   };
   no strict 'refs';
   *$name = $func;
   goto $func;
}
[download]

What this means is that the first time an autoloaded function is called, AUTOLOAD creates the function as a coderef, and then installs that into the symbol table, so that the next time the same named function is called, no AUTOLOAD needs to happen.

And it fixes caller, and stuff that relies on caller like Carp::confess.

use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name

Outstanding!

The AUTOLOAD part is beyond my current understanding but the examples enlightened me to exactly what I needed!

AUTOLOAD is documented here: Autoloading.

arley_ge:

In vi, you could use something like: ?^sub

On a more serious note, when you're writing your code, you know what the name of your subroutine is that you're writing, so I presume you mean to determine the name of the subroutine that's calling the one you're writing. In that case, you could use the caller function to check the stack frame.

If you're meaning that you want the subroutine running at a specific point in time, I guess you could use a timer in conjunction with a signal handler to interrupt your program at a particular point in time. I've never tried it, but if you do so, I'm guessing you could use caller to determine what routine you were in when the signal fired.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

Yes, calling subroutine is what I meant. Doh!

Thanks for your kind reply.

What is the most efficient way to determine the name of the currently executing subroutine?

Its too early to worry about efficiency , start with one way, and it will be good enough

Devel::Trace, caller...

OK, let me correct my quetion...

What is a way to determine the name of the currently executing subroutine?

Or, what is the easiest way to determine the name of the currently executing subroutine?

"...code I inherited"

Can't you show the code you inherited?

Karl