If you are trying it with Getopt::Long, it isn't going to work, unless you quote the command line arguments and do some postprocessing.

Hi, Thanks for your reply.
I was indeed trying it with Getopt::Long ;
Do you suggest any other module which will help me avoid the post processing?
Thanks once again.

...where the key is a string, but the value is an array

You could try something like this:

#!/usr/bin/perl

use strict;
use warnings;
use Getopt::Long;

my $myopts = {};
my $curr_opt = '';
my $curr_key = '';

sub first_opt {
    $curr_opt = shift;
    $curr_key = shift;
    add_opt(shift);
}

sub add_opt {
    my $val = shift;
    $val =~ s/,$//;
    push @{$myopts->{$curr_opt}{$curr_key}}, $val;
}

# some commandline input
{   no warnings "qw";
    @ARGV = qw(
      -cmdline_option1 REG1=value1, value2, value3, value4
      -cmdline_option1 REG2=Value1, Value2, Value3, Value4
      -cmdline_option2 REG1=val1, val2, val3, val4
      -cmdline_option2 REG2=Val1, Val2, Val3, Val4
    );
}

GetOptions (
            'cmdline_option1=s%' => \&first_opt,
            'cmdline_option2=s%' => \&first_opt,
            '<>'                 => \&add_opt,
           );

use Data::Dumper;
print Dumper $myopts;

__END__
$VAR1 = {
          'cmdline_option2' => {
                                 'REG1' => [
                                             'val1',
                                             'val2',
                                             'val3',
                                             'val4'
                                           ],
                                 'REG2' => [
                                             'Val1',
                                             'Val2',
                                             'Val3',
                                             'Val4'
                                           ]
                               },
          'cmdline_option1' => {
                                 'REG1' => [
                                             'value1',
                                             'value2',
                                             'value3',
                                             'value4'
                                           ],
                                 'REG2' => [
                                             'Value1',
                                             'Value2',
                                             'Value3',
                                             'Value4'
                                           ]
                               }
        };
[download]

Assuming that neither the properties (REG1, REG2, etc) nor the values assigned to them have meaningful embedded spaces and commas, this can be parsed with Getopt::Long.

The "@{n,m}" spec syntax tells Getopt::Long to read multiple values after an option even without repeating the option flag, so you can use this spec to get gather together all the values that belong to the -cmdline_option flag. However, once you retrieve all the values for -cmdline_options you will only have an array of values. Getopt::Long doesn't know how to build HoA's for a single option flag so you will have to do it yourself, like this:

use strict;
use warnings;
use Getopt::Long;

# fake populate ARGV
my $sLine= <<EOF;
-cmdline_option REG1=value1.1, value1.2, value1.3, value1.4
-cmdline_option REG2=value2.1, value2.2, value2.3, value2.4
-cmdline_option REG3=value3.1, value3.2, value3.3, value3.4
EOF

@ARGV = split(/\s+/, $sLine);

sub makeKeyValuePairsIntoHoA;

# ====================================================
# parse the command line
# ====================================================

my @aCmdLineOpts;
GetOptions('-cmdline_option=s@{0,}' => \@aCmdLineOpts);
my $hCmdline = makeKeyValuePairsIntoHoA(\@aCmdLineOpts);



# see results
foreach my $k (sort keys %$hCmdline) {
  my $v = $hCmdline->{$k};
  print "$k:<@$v>\n";
}

# ====================================================
# subroutine for making key-value pairs into an HoA
# ====================================================
sub makeKeyValuePairsIntoHoA {
  my ($aValues) = @_;
  # consolidate arguments so that all the
  # values belonging to REG1= are in a single
  # comma delimited list without spaces.

  my $sAllInOne = join(' ', @$aValues);
  $sAllInOne =~ s/\s*,\s*/,/g;

  # split into key-value pairs on whitespace
  my @aKeyValuePairs = split(/\s+/, $sAllInOne);
  my %hKeyValuePairs = map
    { my ($k,$v) = /(\w+)+=(.*)/;
      $k => [ split(/,/, $v) ]
    } @aKeyValuePairs;

  return \%hKeyValuePairs;
}
[download]

Best, beth

Consider:

1. Breaking up your cli into smaller pieces

   I.E. If your 'bin/cli' will clean the car if you pass it the --clean-car flag, consider moving that functionality to 'bin/clicleancar'

2. Using a data file as input

   If this is a complex procedure, would it be useful to accept as input a YAML config file as option paramaters?

Ultimately you're the judge of this.

You may be in a situation a-la imagemagick, or mplayer .. these projects have already broken up their functionality into mplayer/mencoder/etc.. and convert/mogrify/etc. But the nature of the beast is such- that their cli is a monster.