It's said that every programmer has to invent a template system or a vocabulary trainer.

And it seems every Perl hacker has to try to parse Perl. ;-P

... well ... how can I help you?

Do you want ...

• ... links to other projects trying to do the job with regexes in order to have a look into the code? *
• ... suggestions how to make your regex better maintainable by nesting regexes for different sub-grammars?
• ... a link where Merlyn shows that Perl can't be statically parsed because any imported sub with prototype can change how the parser proceeds?

Just a simple example

• you need to exclude subs inside POD or strings from your listing.
• strings are not easily detected because we have q and qq operators.
• ...

  q!
    sub :attr() {
        print "bla"
     }
  !
  [download]

edit

*) like PPR,

update

From your module

> Files are parsed using PPI, not by inspecting packages or op-trees.

I think it's clearer if you say

> Files are statically parsed using PPI, not by dynamically inspecting packages or coderefs.

> like PPR ...

you may want to have a look at the following tests

https://metacpan.org/source/DCONWAY/PPR-0.000021/t/ppi_statement_sub.t

and

https://metacpan.org/source/DCONWAY/PPR-0.000021/t/subdecl.t

I wasn't able to find examples of attributes with arguments, so better see the corresponding perldoc in perlsub#Subroutine-Attributes

Examples of valid syntax (even though the attributes are unknown):

sub fnord (&\%) : switch(10,foo(7,3))  :  expensive;
sub plugh () : Ugly('\(") :Bad;
sub xyzzy : _5x5 { ... }

Examples of invalid syntax:

sub fnord : switch(10,foo(); # ()-string not balanced
sub snoid : Ugly('(');        # ()-string not balanced
sub xyzzy : 5x5;              # "5x5" not a valid identifier
sub plugh : Y2::north;        # "Y2::north" not a simple identifier
sub snurt : foo + bar;        # "+" not a colon or space
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

Depending on how much you can constrain your input, you could look at the regex I use in Filter::signatures to recognize subroutine signatures. The regexes somewhat cheat as they leave parsing of quotes and quote-likes to Filter::Simple / Text::Balanced, so you either need to use these modules or restrict your code to sane / easy string constructs.

The most simple version is this. It is compatible with 5.8, but doesn't handle nested parentheses.

# This is the version that is most downwards compatible but doesn't ha
+ndle
# parentheses in default assignments
sub transform_arguments {
        # This should also support
        # sub foo($x,$y,@) { ... }, throwing away additional arguments
        # Named or anonymous subs
        no warnings 'uninitialized';
        s{\bsub(\s*)(\w*)(\s*)\((\s*)((?:[^)]*?\@?))(\s*)\)(\s*)\{}{
                parse_argument_list("$2","$5","$1$3$4$6$7")
         }mge;
        $_
}
[download]

This fails for example for:

sub fail58( $time = localtime() ) {
[download]

The recursive regex used for 5.010 onwards is more complex because it handles matched parentheses and curly braces.

sub transform_arguments {
    # We also want to handle arbitrarily deeply nested balanced parent
+heses here
        no warnings 'uninitialized';

        s{\bsub(\s*)       #1
           (\w*)           #2
           (\s*)           #3
           \(
           (\s*)           #4
           (               #5
                (          #6
                   (?:
                     \\.            # regex escapes and references
                     |
                     \(
                         (?6)?      # recurse for parentheses
                     \)
                     |
                     \{
                         (?6)?      # recurse for curly brackets
                     \}
                     |
                     (?>[^\\\(\)\{\}]+) # other stuff
                     )+
                )*
             \@?                    # optional slurpy discard argument
+ at the end
           )
           (\s*)\)
           (\s*)\{}{
                parse_argument_list("$2","$5","$1$3$4$8$9")
         }mgex;
        $_
}
[download]

If this is for parsing your own code, you usually can rewrite/restrict your code to a limited subset of what Perl allows. If you want a generic "subroutine declaration finder", you have a hard task in front of you.

Hi,

PPI has no problem with this

sub     # keyword
Routine # identifier
{       # new block
'
sub     # keyword
Routine # identifier
{       # new block
  "PPI"
}

'
}
[download]