You don't need eval and you can just inspect the main namespace for whether a subroutine of that name is defined:

use strict;
use Data::Dumper;
sub foo {
    print "foo\n";
}

for my $subname (@ARGV) {
    my $glob = $::{$subname};

    warn defined $glob ? "'*$subname' exists"
                       : "'*$subname' not found";
    if ($glob) {
        my $sub = *{$glob}{CODE};

        warn defined $sub ? "'$subname' exists"
                          : "'$subname' not found";


        &$sub if $sub
    };
}
[download]

couldn't you just do

if ( my $sub = main->can($subname) ) {
    $sub->(...)
}
[download]

?

Not quite. can is meant for methods, so it obeys inheritance.

The reason I decided to use eval is that the user can put the required code in a package, and I don't need to know anything about it as long as he uses the fully qualified name as the subroutine name.

Out of curiosity, how would you examine the symbol table for a package whose name you get from a variable? I'm not very comfortable with the syntax for typeglobs and Perl symbol tables...

You can inspect any package, as the symbols for My::Package live in the %My::Package:: hash. The easiest way to get at those hashes is via soft references:

use strict;
use Data::Dumper;

my $package = 'Data::Dumper'; # just as an example
{
    no strict 'refs'; # we're using strings as symbols. Nasty, but con
+venient
    warn Dumper \%{ "$package\::" };
};
[download]

If you're going to call the sub anyway, call it in an eval and see what happens. If some other error comes up, you can rethrow it with die.

eval { &$sub };
if ( $@ =~ /^Undefined subroutine/ ) {
    # This is what happens when you call a bogus sub ref.
}
elsif ( $@ ) {
    die $@;
}
[download]

Probably $sub->() is a better idiom, for the same reason to prefer prefered() to &prefered -- no accidental arg passing.

print "valid\n" if defined &$sub;
[download]

Dave.

#!/usr/bin/perl
use strict;

sub foo {
    print defined $_[0] ? "It is me, $_[1]!\n" :
                          "$_[1] does no live here.\n";
}

my $sub = *nonfoo{CODE};
foo($sub, "nonfoo");

$sub = *foo{CODE};
foo($sub, "foo");
__END__
nonfoo does no live here.
It is me, foo!
[download]

You can't tell if a code ref actually has code behind it that way. \&anyNameHere will return an apparently valid code ref. The only way is to actually invoke it, so do the invocation within an eval block:

print $_, ':', eval{ $_->(); 1 } ? "S'ok" : "Uht erd!" 
    for sub{ print 'good code' }, \&doesNotExist;;

good code
CODE(0x194a9b4) : S'ok
CODE(0x194a954) : Uht erd!
[download]

use warnings;

use Inline C => Config =>
    BUILD_NOISY => 1;


use Inline C => <<'EOC';

SV * validate(CV * coderef) {
     if(CvOUTSIDE(coderef)) return newSVuv(1);
     return newSVuv(0);
}

EOC

$cref1 = \&existent;
$cref2 = \&non_existent;
$foo = 'hello world';

print "\$cref1: ", validate($cref1), "\n";
print "\$cref2: ", validate($cref2), "\n";
print "\$foo: ", validate($foo), "\n"; # Fatal Error

sub existent{}
[download]

defined (which already provides this functionality) and sub calls use CvROOT(sv) || CvXSUB(sv).

Update: Only mentioned defined initially.

defined (which already provides this functionality)...

Yes, defined(&$sub) works fine, but the functionality seems different to me. My approach looks at the variable itself, whereas defined appears to be looking at the subroutine referenced by the variable.

Anyway .... my point is very moot .... at best :-)

Cheers,
Rob

eval do { local $/; <DATA> }; # psuedo require!
die $@ if $@;

for my $sub ( 'foo', 'undefined' ) {
    if ( main->can($sub) ) {
        main->$sub;
    }
    else {
        print "$sub() not defined\n";
    }
}

__DATA__
sub foo {
    print "foo() worked\n";
}
[download]

I've got a little module/pragma that will spot this kind of problem at compile-time: see "pragma" ensure...

...I'm interested in whether people find it useful. So any and all comments gratefully received.