#!/usr/bin/perl -w

use strict;

sub here {
}

foreach my $poss ( qw( here not_here ) ) {
    no strict 'refs';
    if (*{$poss}{CODE}) {
        print "$poss exists.\n";
    } else {
        print "$poss does not.\n";
    }
}
[download]

Update: I just read the 'reference' part. If it's an anonymous reference, that's trouble. (I think you'd have to get access to Perl guts to find it. Yikes.) If it's not, you can check the symbol table for a match. There's probably a better way to do this with grep, but this is illustrative:

#!/usr/bin/perl -w

use strict;

sub findme {
    return 0;
}

sub another {}

my $ref;

if (rand(1) < 0.5) {
    $ref = \&findme;
} else {
    $ref = \&another;
}

foreach (keys %main::) {
    no strict 'refs';
    if (defined *{$_}{CODE}) {
        if (*{$_}{CODE} eq $ref) {
             print "\$ref points to $_!\n";
        }
    }
}
[download]

That was what I originally thought, but the problem is that I don't have the subroutine name, I only have a code ref. And as btrott points out, it might well be an anonymous code ref (which doesn't live in a typeglob).

--
<http://www.dave.org.uk>

European Perl Conference - Sept 22/24 2000, ICA, London
<http://www.yapc.org/Europe/>

Very nice!

OTOH I use anon subs a lot, and this approach will fail for those.

Incidental note. After some testing it appears that if the sub exists when you define the sub reference, you get the first sub. Otherwise you get the first sub defined after that with that name. I tried various combinations of evals creating refs, defining subs, redefining subs, and that seemed to be what happened.

Personally I would not worry about it. But I would like it if "strict 'subs'" disallowed making a reference to a sub that is not yet defined...

Thanks everyone for your help, but I think I've got a solution - and it's even simpler than I hoped for. Take a look at this:

sub there {
  print "I'm here!";
}

my %refs = (there => \&there,
            not => \&not_there,
            anon => sub { "I'm here too!" });

foreach (keys %refs) {
  print "'$_' is ", defined &{$refs{$_}} ? "valid\n" : "invalid\n";
}
[download]

Which displays:

'there' is valid
'not' is invalid
'anon' is valid
[download]

Much kudos to Matt Freake of London.pm for coming up with the solution - defined &$coderef.

Think of anonymous subs, for example:

    printf "%s\n", sub { "foo" };
[download]

    CODE(0x45f73b0)
[download]

    my $type = ref $sub;
[download]

The only "solution" really may be to try and run the sub. I guess the problem here is that the only way of dereferencing a code reference is to *run* it; and that's what you want to avoid. But if that's the only way, then... anyway.

I hope to see some more encouraging answers, though.

I notice that the debugger's "x" command seems to know how to do this so I dug a bit and found Devel::Peek::CvGV(), which will fail if your ref is to a sub that doesn't exist.

Welcome to autovivification. By creating the ref you implicitly tell perl to assume it exists, and so the reference is created, despite the non-existence of the sub. From perldoc perlref:

6.  References of the appropriate type can spring into existence if yo
+u
    dereference them in a context that assumes they exist. Because we
    haven't talked about dereferencing yet, we can't show you any
    examples yet.
[download]

3.  Subroutine calls and lookups of individual array elements arise
    often enough that it gets cumbersome to use method 2. As a form of
    syntactic sugar, the examples for method 2 may be written:
        $arrayref->[0] = "January";   # Array element
        $hashref->{"KEY"} = "VALUE";  # Hash element
        $coderef->(1,2,3);            # Subroutine call

    The left side of the arrow can be any expression returning a
    reference, including a previous dereference. Note that `$array[$x]
+'
    is *not* the same thing as `$array->[$x]' here:

        $array[$x]->{"foo"}->[0] = "January";

    This is one of the cases we mentioned earlier in which references
    could spring into existence when in an lvalue context. Before this
    statement, `$array[$x]' may have been undefined. If so, it's
    automatically defined with a hash reference so that we can look up
    `{"foo"}' in it. Likewise `$array[$x]->{"foo"}' will automatically
    get defined with an array reference so that we can look up `[0]' i
+n
    it. This process is called *autovivification*.
[download]

UPDATE: Never mind: merlyn pointed out that autovivification yields a structure with stuff in it, unlike this (the coderef exists, but it's useless). But it's still good to know :-).