CPAN is your friend :) I've found these modules:

• Devel::DProf
  

  The Devel::DProf package is a Perl code profiler. This will collect information on the execution time of a Perl script and of the subs in that script. This information can be used to determine which subroutines are using the most time and which subroutines are being called most often. This information can also be used to create an execution graph of the script, showing subroutine relationships.

• Devel::Profiler
  

  This module implements a Perl profiler that outputs profiling data in a format compatible with dprofpp, Devel::DProf's profile analysis tool. It is meant to be a drop-in replacement for Devel::DProf.

• Devel::AutoProfiler by samtregar
  

  The profiler module is completely automatic in its basic mode. You simply "use" the module at the top of you main script. The module will then automatically instrument all subroutines in the code, profile each subroutine call during the execution of the script, and print out a report of usage.

There also some nodes here at the Monastery:

• Module dependency tool?
• robustly list any Perl code's module dependencies
• Check a script's module dependencies
• Generate UML from Perl code?
• MoDetails v0.2 by hacker
• Creating a Dependency Tree Using the Tree::DAG_Node Module and Postorder Transversal
• Any UML tool for Perl?
• Perl UML conventions
• UML for PERL?

Ciao, Valerio

update: added some links. For the women part look at Sex Tips For Geeks: How To Be Sexy and for the ironing: Extreme Ironing :)))

Hi Valerio

yes, I know about DProf, but I was looking for static analysis. DProf requires you to run the code, it then profiles it and you can look at e.g. which subroutines are slowest. It can also print out a subroutine call tree, however, I don't know that there are any ways of limiting this call tree to only show "my" code (not code from external modules I am using.)

While I'm on the subject, one more wish I forgot: use everywhere; - a way to import stuff to all my namespaces. Useful for quick development, e.g. use everywhere 'Data::Dumper', qw/Dumper/;

dave hj~

I think your best bet would be detailed runtime tracing using caller, perhaps hooked in with Devel::AutoProfiler

True. As I said, I wouldn't expect this code to understand stuff like evals. Just to get the vanilla stuff.

Actually, the request for "static" wasn't because I really can't run the program. It was more to direct people's attention away from runtime characteristics of the code, and towards the structure of the code. For example, finding subroutines which never get called (I assume that trying to do this at runtime would involve us in the halting problem :-)

dave hj~

if you're rather consistant in your coding style (or maybe after a run through perltidy) and you're familiar with the way the code is constructed then it seems you could do some of what you want with simple text processing.

just grep for /sub/ and build a list of your named subroutines, then grep for the subroutine names on lines that don't match /sub/.

i've been planning to look at perltidy's source for ideas along the same lines as your question. i figure if perltidy can grok perl enough to colorize and format perl nicely then it might be easy enough to make it do other transformations on the code. i'd like to be able to do something like:

package F;
my %D = ( foo => 1 );
sub new { my ($c,%p) = @_; my %s = ( %D, %p ); return bless \%s, $c; }
sub f_1 { my $s = shift; ... }

package main;
my $f = new F;
print $f->f_1('blah');
[download]

and then be able to generate a transform file.

F           -> Foo
 %D         -> Default
 &new
  $c        -> class
  %p        -> parameter
  %s        -> self
 &f_1       -> marble
  $s        -> self
main
 $f         -> foo_obj
[download]

and then be able to swap back and forth. most of the stuff i need to get done deals with tight name domains, and by that i mean that:

j  is a jack
h  is a host
ac is an account
t  is a topology
p  is a port
v  is a vlan
n  is a netmask
b  is a building
r  is a room
m  is a MAC address
[download]

it doesn't confuse me at all, might be because i started BASIC back in the early Apple II days when you could only use single character variables, and the days of Fortran where the initial character represented int/float, or maybe because i was a physic major and they'll go into foreign characters before they'll use longer varibles.

but i realize that for the people who look at my code when i'm done just see noise unless the variables are longer.

once the code is actually written i don't have a problem with the names being long, i just haven't found a better way as of yet than manually (vim, so it isn't that hard =)

I wanted to second zengargoyle's comment above (++). If you restate the problem as finding subroutines which are never mentioned, as opposed to called, you could do various grep-type searches. Of course, Perl's complex syntax makes it difficult to identify even mentions of subroutines with real precision. If you have a sub called add, for example, you need to know that print "add" is not a subroutine call, but that print "@{[ add ]}" is.)

As for edit my code and change names of a variable or subroutine, wherever it's referred to... well, I admit I typically use a low-tech solution in my editor called "search and replace" :-)

To warn me about private subroutines (sub _foo) being called from outside their class/subclasses: Seems like you could insert a line at the beginning of the private sub that would check UNIVERSAL::isa to see if the calling object is a descendant of the appropriate type.

And finally, increase my attractiveness to women. I am inclined to respond that "I have discovered a truly remarkable technique which this textbox is too small to contain." (With tongue firmly in cheek, and copious apologies to Pierre de Fermat.)

        $perlmonks{seattlejohn} = 'John Clyman';

perl -pi -e 's/\$oldname\b/\$oldname/g' <files>
[download]

:%!perl -pe 's/\$oldname\b/\$oldname/g'
[download]

czth