Here is an example which can get you started: How can I write a Perl script to extract the source code of each subroutine in a Perl package?

Should I use PPI::Transform to edit the subroutines?

From the CPAN page, I got that I could do something like this:

my $transform = PPI::Transform->new(
    param1 => 'value1',
    param2 => 'value2',
);

# Change a file in place
$transform->file( 'Change.pm' );
[download]

But I don't understand what are the params and values when creating the new transform object.

Okay, I got it now, after going through the CPAN documentation a bit more.

use strict;
use warnings;
use PPI;

my $file = '/path/to/perl/script.pl';
my $Document = PPI::Document->new($file) or die "oops";

for my $sub ( @{ $Document->find('PPI::Statement::Sub') || [] } ) {
    unless ( $sub->forward ) {
        my @elements = $sub->children;

        for ( my $i = 0 ; $i < @elements ; $i++ ) {
            if ( ref $elements[$i] eq "PPI::Structure::Block" ) {
                $elements[$i]->start->add_content("my mars code");
            }
        }
    }
}

$Document->save($file.".new");
[download]

Do you need the text to be in the files or do you need to do something at the start of the subroutines' execution? If the later, have a look at Hook::LexWrap, Class::Wrap and possibly Devel::TraceSubs for an example how to wrap everything in a package.

Okay, so I tried the following code:

#!/usr/bin/perl
use warnings;
use strict;
use Hook::LexWrap;

my @mars_subs = qw (add increment);
for (@mars_subs) {
    wrap $_, pre => sub {
        my @caller = caller(0);
        for (@caller) {
            print $_, " " if defined $_;
        }
        print "\n";
    };
}

print add( 1, 2 ), "\n";

sub add {
    my ( $num1, $num2 ) = @_;
    increment($num1);
    return $num1 + $num2;
}

sub increment {
    my $num = shift;
    return ++$num;
}
[download]

And the output I got is:

main hooklexwrap.pl 17 main::__ANON__ 1 1 1794 UUUUUUUUUUUUU
main hooklexwrap.pl 21 main::__ANON__ 1 1538 UUUUUUUUUUUUU
3
[download]

How do I get the actual sub names like main::add instead of main::__ANON__ ?

What are you trying to report? Are you trying to emit something for every executed function? In that case, close over the name of the wrapped function:

my @mars_subs = qw( add increment );

for my $sub (@mars_subs) {
    wrap $sub, pre => sub {
        print "Calling '$sub'\n";
    };
}
[download]

---

Improve your skills with Modern Perl: the free book.

It might be a good idea to do this in code.

sub marsify {
  my ($func) = @_;
  
  return sub {
    my @mars_caller =  caller(0);
    mars::print::call(\@mars_caller, \@_);
    $func->(@_);
  }
}

# enumerate through package symbols, finding subroutines

# for each sub found
# patch symbol table:
*subname = marsify(\&subname);
[download]

I'm sure someone can fill me in -- I'm not familiar enough with the symbol table tricks to pull this off.