Is there way to determine method/function names for loaded module?

package Foo;

sub new { bless {}, shift }
sub foo { print "i'm a method of Foo\n" }

package main;

my $o = Foo->new();
print "foo exists\n" if $o->can('foo');
print "bar does not exist\n" unless $o->can('bar');

__output__

foo exists
bar does not exist
[download]

_________
broquaint

This way can be used when I have some idea about function name:) I want to obtain list of all functions - don't know function names...

Then just dump the symbol table of your given package either by hand or using Juerd's Devel::GetSymbols. If you want to roll you own something like this ought do the trick

package Foo;

our $VERSION = 0.1;

sub new { bless {}, shift }
sub foo { print "i'm a method of Foo\n" }

package main;

for my $sym (keys %Foo::) {
    print "method - $sym\n" if *{"Foo::$sym"}{CODE};
}

__output__

method - foo
method - new
[download]


HTH

_________
broquaint

How? Look for functions referenced in the %{PACKAGE_NAME::} hash. Here's an example...

#!/usr/local/bin/perl -w

# Find all functions in specified package
my $pkg = shift;

eval "use $pkg; 1"
  or die "Failed to load $pkg: $@\n";

# print functions
while (my ($key, $val) = each %{"${pkg}::"}) {
  print "$key\n" if defined *{$val}{CODE};
}
[download]

Note that we're using some symrefs here (to access the %{"${pkg}::"} hash), so as least that line should be free of strictness.

Sure, read the documentation (or the source code).

You can probably get a good first approximation by looking at the package's symbol table (using something like Devel::Symdump perhaps, but in general it's very difficult to do it accurately because things like inheritance and AUTOLOAD.

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

Yes, of course - read documentation. My question was slightly bad.

I need it for debuging purposes. My module use AUTOLOAD to generate new methods and I want to query for names of generated (and not only) methods.

Here's a little routine I whipped up that should handle the @ISA path for a class. Mind, it still won't tell you about tricky additions to the method space such as auto-loaded methods that aren't pre-declared with "use vars", for example. In other words, you can fool it pretty easily but if you're using the code in a fairly plain environment, it should at least be helpful.

sub find_methods
{
    my $pack = shift;
    my $tbl  = shift || {};

    no strict 'refs';

    my ($key, $val);
    while (($key, $val) = each %{"${pack}::"})
    {
        $tbl->{$key}++ if defined *{$val}{CODE};
    }
    if (@{"${pack}::ISA"})
    {
        find_methods($_, $tbl) for (@{"${pack}::ISA"});
    }

    sort keys %$tbl;
}
[download]

It assumes that the code behind the specified class has already been loaded. You call it as:

@methods = find_methods $classname;

You won't get duplicate names in the cases where a sub-class overrides a method previously defined in a parent. Recursion is your friend.

--rjray

Now, if you cannot (or will not) do an execution trace by hand (or in your head), then that's another problem altogether.

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.