bareword='quoted\'s string'
bareword='quoted''s string'
bareword="quoted \"string\""
[download]

Agreed, though there's no current requirement to support escaping in the quoted strings. But that's exactly the sort of reason I'm unhappy about the duplicated regexp chunks, since it'd be easy to enhance one of the ' ([^']*) ' fragments and miss the other.

Similarly, I could collapse the single- and double-quoted string checks with a style like   (["']) (.*?) \1, but that can make tracking the capture numbers even harder, since now a change in the regexp would mean updating the numbering elsewhere in the pattern as well as in the push @args, ... code.

Hugo

# skip initial whitespace, if any
$tag =~ /^\s*/gcxs;

# look for optional key, and a bareword or the start of a quoted strin
+g
while ($tag =~ / \G (?: (\w+) \s* = \s*)? ( ['"](?=.) | \w+ ) /gcxs) {
    my ($k, $v) = ($1, $2);

    # extract quoted string
    if ($v eq "'" || $v eq '"') {
        $tag =~ / \G ( (?: \\. | [^$v] )* ) $v /gcxs or last;
        $v = $1;
        $v =~ s/\\(.)/$1/g;    # unescape characters
    }

    # skip optional separator
    $tag =~ / \G \s* :? \s* /gcxs;

    # save value
    push @args, $k ? [$k, $v] : $v;
}

# check if parsing was successful
die if pos $tag != length $tag;
[download]

•Update: If you like, you can ofcourse precompile the quote-patterns so you don't have any variable patterns, like:

my %quotes;
$quotes{$_} = qr/ \G ( (?: \\. | [^$_] )* ) $_ /xs for qw(' ");
[download]

    if (my $pat = $quotes{$v}) {
        $tag =~ /$pat/gc or last;
        $v = $1;
        $v =~ s/\\(.)/$1/g;
    }
[download]

Thanks, that's an interesting approach. I find the logic still rather complex, though, and I think if I were going in this direction I'd separate it out a bit differently:

  while (pos($tag) < length($tag)) {
    if (m{ \G (\w+) \s* = }gcx) {
      push @args [ $1 ];
    } elsif (m{ \G (\w+) (?= \s* | \z ) \s* }gcx) {
      push @args, $1;
    } elsif (m{ \G (['"]) ( \\. | [^\\] )*? \1 \s* }gcx) {
      (my $quoted = $2) =~ s/\\(.)/$1/g;
      push @args, $quoted;
    } else {
      die "parsing error\n";
    }
  }
  for (my $i = 0; $i < @args; ++$i) {
    $args[$i][1] = splice(@args, $i + 1, 1) if ref $args[$_];
  }
[download]

Hugo

There are many variations possible. I have to admit yours is simpler, although I should note it parses a different language than your original request ("foo=foo=foo=foo=" is considered valid in this version)

BTW, benchmarks have shown using .*?D is slower than [^D]*D (where D is the delimiter).

Also note using [^\\] is not necessary, though harmless (since if the char is a backslash, the \\. will match unless the backslash is end the end, which case there's also no delimiter and the whole pattern will not match).

And finally, in your original you used the /s while you're not using it here.. I don't know if that's deliberate or a mistake, but I thought I'd note it.

•Update: and I just noticed you completely forgot support for the colon-delimiter (although that's not hard to add). Also that (?= \s* | \z ) zero-width assertion is completely futile since it also matches 0 chars (due to the \s*).

Thanks, I'll have to take a closer look at that. At first glance it seems I'll still have to do some parsing on the resulting token stream, and I'm not sure how much cleaner the resulting code would be. In particular, I'd have to keep the delimiters to be able to distinguish between key=value and "not=a key", and then reparse them out again.

Hugo