#!/usr/bin/perl

my $line = <DATA>;
chomp $line;

my $options = {};

for (split /(?=\s\S+\s*=)/, $line) {
    my ($option, $value) = split /=/, $_;

    $option =~ s/^\s+//;
    $option =~ s/\s+$//;

    $options->{$option} = $value;
}

use Data::Dumper;
print Dumper $options;

__DATA__
option1 = value0 value1 value2 option3 =value3 value4 option2=value5
__END__
$VAR1 = {
          'option1' => ' value0 value1 value2',
          'option3' => 'value3 value4',
          'option2' => 'value5'
        };
[download]

-sauoq
"My two cents aren't worth a dime.";

Thanks very much sauoq,

Even though I can sort of read positive/negative-look-ahead regexs, I still haven't been able to exploit it effecitively in my code! Whenever I am stuck like this next time I should try out that type of solution :)

Just for other people's benefit, I shall try to explain your solution. Please correct me if i am wrong

Input: option1 = value0 value1 value2 option3 =value3 value4 option2=v
+alue5
split /(?=\s\S+\s*=)/, $line
[download]

Here the regex looks for positions where there is a space followed by more than one non-space char and then an =. When such a position is found, it splits on null char. Here, it will split right before option3 = (for the first time). We can also modify this regex slightly to make it -  /\s+(?=\S+\s*=)/.

Thanks very much.

Also thanks to QM and pg for their suggestions/solutions!

cheers

SK

Another way:

use Data::Dumper;

use strict;
use warnings;

my $params = "option1 = value0 value1 value2 option3 =value3 value4 op
+tion2=value5";
$params =~ s/\s*=\s*/=/g;
my @params = split /\s+/, $params;
my %params;
my $cur_val;
for my $param (@params) {
    my @pairs = split /=/, $param;
    $cur_val = $pairs[0] if ($#pairs) ;
    push @{$params{$cur_val}}, $pairs[-1];
}
print Dumper(\%params);
[download]

Which gives:

$VAR1 = {
          'option1' => [
                         'value0',
                         'value1',
                         'value2'
                       ],
          'option3' => [
                         'value3',
                         'value4'
                       ],
          'option2' => [
                         'value5'
                       ]
        };
[download]

Update: Corrected link (thanks sk).

my $data = <DATA>;

my %hash;
$hash{$1} = $2 while $data =~ s/\s*(\w+)\s*=\s*([^=]+)$//;

use Data::Dumper; print Dumper \%hash;

__DATA__
option1 = value0 value1 value2 option3 =value3 value4 option2=value5
[download]

Not the fastest possible solution, but simple and concise.

As dwildesnl suggested, reversing makes it significantly faster: see benchmark below. But don't do the optimisation unless you need it!

my $data = <DATA>;

use Benchmark "cmpthese";
cmpthese(10_000, {

  "reversed" => sub { my %hash;
      my $reversed_data = reverse($data);
      $hash{reverse($2)} = reverse($1)
          while $reversed_data =~ /\s*([^=]+?)\s*=\s*(\w+)/g;
  },

  "non-reversed" => sub { my %hash; my $data = $data;
      $hash{$1} = $2 while $data =~ s/\s*(\w+)\s*=\s*([^=]+)$//;
  },

});

__DATA__
option1 = value0 value1 value2 option3 =value3 value4 option2=value5
[download]

gives results:

                Rate non-reversed     reversed
non-reversed  1263/s           --         -89%
reversed     10989/s         770%           --
[download]

But don't do the optimisation unless you need it!

What would be the penalty of performing the optimisation if you don't need it?

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

my %options = ();
while (<>) {
    my (undef, @options) = split /(\S+)\s*=/;
    %options = (%options, grep s/^\s*|\s*$//g, @options);
}
[download]