The following gives the output you want with the provided example:

#!/usr/bin/env perl

use 5.010;
use strict;
use warnings;

my $cmd = '&COMPAREEQUAL(First-param.one, Second.param,Third-param)';

my $cms_re = qr{
    (?: [&( ] )?
    (
        [^(), ]+
    )
    (?: [(,)] )?
}x;

say for $cmd =~ m{$cms_re}g;
[download]

Output:

$ pm_cmd_args_regex.pl
COMPAREEQUAL
First-param.one
Second.param
Third-param
[download]

Thank you - this is beautiful, elegant, simple and operational.

I modified it slightly to remove what I thought was unnecessary grouping - this still works:

qr{ 
    \&?          # Leading char for Sub-name -
   ( [^(),\s]+ ) # Sub-name OR arg
    [(,)]?       # Trailing "(" or comma
 }x;
[download]

Thanks also to others who posted working solutions.

As a learning experience, I would also like to understand why the repetition attempt in my O.P - the one without the /g - did not work. Any assistance on that ?

             I hope life isn't a big joke, because I don't get it.
                   -SNL

A regular expression without /g will always match a string from the start, and only once. You need /g for making the engine try multiple times. Your for loop only gets one result. Whether that result is the first target or the last target hinges on where your regex can match.

my $cmd = q|&COMPAREEQUAL(First-param.one, Second.param,Third-param)|;
if ($cmd =~ /^&([^(]+)\(([^)]+)\)$/) {
 my $sub = $1;
 my @args = split /,\s*/,$2;
 print Dumper [ $sub, \@args ];
}
__END__
$VAR1 = [
          'COMPAREEQUAL',
          [
            'First-param.one',
            'Second.param',
            'Third-param'
          ]
        ];
[download]

I think you're looking for the balance parenthesis regex of Jeffery Friedl. After tweeking for quoted strings it looks something like ...

 my ($np);
 # The initial balance parentheses expression with an embedded set is:
 # $np=qr/\( ([^()] | (??{$np})) *\)/x;
 # And quoted strings are "(?:[^"]|\")*" and '(?:[^']|\')*' or ('|")(?
+:[^\1]|\\1)*\1 so
 $np=qr/
          \(                           # The opening "("
              ((                       # We'll want this hence the cap
+turing ()
                  '(?:[^']|\')*?'      #' a single quote string
                  | "(?:[^"]|\")*?"    #" a double quote string
                  | [^()]              # not a parentheses
                  | (??{$np})
              )*)
          \)                           # and the closing ")"
      /x;
[download]

Hi, NetWallah,

The OP is indeed interesting and goads me into this.

Thanks!

#!/usr/bin/perl

use strict;
use warnings;
use Smart::Comments;

    print "\n" x5;
    my ($np_1,$np_2);
    # The initial balance parentheses expression with an embedded set 
+is:
    # $np=qr/\( ([^()] | (??{$np})) *\)/x;
    # And quoted strings are "(?:[^"]|\")*" and '(?:[^']|\')*' or ('|"
+)(?:[^\1]|\\1)*\1 so
    $np_1=qr/
             \(                            # The opening "("
                 ((?:                      # We'll want this hence the
+ capturing ()
                     | [^'"()]             #' not a ' " ( or )
                     | (?:'(?:[^']|\')*?') #' a single quote string
                     | (?:"(?:[^"]|\")*?") #" a double quote string
                     | (??{$np_1})         # parenthesized expression
                 )*)
             \)                            # and the closing ")"
         /x;
    # Deal with the argument list
    $np_2=qr/
             (                             # We'll want this hence the
+ capturing ()
                 (?:                       #
                     [^'"(),]              #' not a ' " (  ) or ,
                     | (?:'(?:[^']|\')*?') #' a single quote string
                     | (?:"(?:[^"]|\")*?") #" a double quote string
                     | $np_1               # parenthesized expression 
+see above
                 )*
             )(,|\z)                       # termining , or \z
         /x;
  my $string=q{other stuff &COMPAREEQUAL(First-param.one,'(,',Third-pa
+ram); more stuff other stuff &COMPAREEQUAL(one(foo('bar'))+two(foobar
+),'(,',Third-param); more stuff dude() };
  ### $string
  while ($string =~ m/\b(\w+)\s*$np_1/g) {
        my ($subroutine_name,$argument_list)=($1,$2);
        ### $subroutine_name
        ### $argument_list
        while ($argument_list =~ m/$np_2/g and $1) {
            ### argument: $1
             };
         };
__END__
[download]

### $string: 'other stuff &COMPAREEQUAL(First-param.one,\'(,\',Third-p
+aram); more stuff other stuff &COMPAREEQUAL(one(foo(\'bar\'))+two(foo
+bar),\'(,\',Third-param); more stuff dude() '

### $subroutine_name: 'COMPAREEQUAL'
### $argument_list: 'First-param.one,\'(,\',Third-param'

### argument: 'First-param.one'

### argument: '\'(,\''

### argument: 'Third-param'

### $subroutine_name: 'COMPAREEQUAL'
### $argument_list: 'one(foo(\'bar\'))+two(foobar),\'(,\',Third-param'

### argument: 'one(foo(\'bar\'))+two(foobar)'

### argument: '\'(,\''

### argument: 'Third-param'

### $subroutine_name: 'dude'
### $argument_list: ''
[download]

Its got something to do with $2 being a scalar, and being able to contain only a single value -- try the following with  -Mre=debug

$ perl -le " $_ = q{abcdef}; print for m{(.)(.)}g;
a
b
c
d
e
f

$ perl -le " $_ = q{abcdef}; print for m{(.)(.)*}g;
a
f
[download]

So I think the (old) idiom is this

$cmd=q|&COMPAREEQUAL(First-param.one, Second.param,Third-param)|;

my $re = qr{
\G
(?:
        \&
    |
        (\w+) # $1
        \(
    |
        (?:
            ( # $2
              [^,\)\s]+ 
            )
            |
            (?:
                [,\s]+
            )
        )
    |
        \)
)
}mx;

while( $cmd =~  m{$re}g ){
    use Data::Dump; dd [ $1, $2 ];
}

__END__
[undef, undef]
["COMPAREEQUAL", undef]
[undef, "First-param.one"]
[undef, undef]
[undef, "Second.param"]
[undef, undef]
[undef, "Third-param"]
[undef, undef]
[download]

Double-undef is when the non $1/$2 parts match