Update: - looks like I obviously didn't even remotely understand what you were after, so just pretend I didn't post the below :)

#!/usr/bin/perl -w
use strict;
use Data::Dumper::Simple;

my $string = "TXXXABCDGXXXCCCDTGYYYCCCYYYCC";

my @wanted = split /XXX|YYY/, $string;

print Dumper(@wanted);
[download]

@wanted = (
            'T',
            'ABCDG',
            'CCCDTG',
            'CCC',
            'CC'
          );
[download]

Cheers,
Darren :)

Take advantage of regexp backtracking to find all the possibilities.

my $str = "TXXXABCDGXXXCCCDTGYYYCCCYYYCC";
local our @matches;
$str =~ m/
   (XXX.*YYY)                 # Search and capture
   (?{ push @matches, $1 })   # Save result
   (?!)                       # Try again
/x;  
print "$_\n" foreach @matches;
[download]

outputs

XXXABCDGXXXCCCDTGYYYCCCYYY
XXXABCDGXXXCCCDTGYYY
XXXCCCDTGYYYCCCYYY
XXXCCCDTGYYY
[download]

Update: Followed japhy's suggestion

Replace (?=a)(?!a) with simply (?!).

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart

Dear ikegami,
To confirm my understanding on the use of "local our".
You mean in this context right?


foreach my $ss (@str_set) {
    local our @matches;
    $ss =~ m/
          (XXX.*YYY)                 # Search and capture
          (?{ push @matches, $1 })   # Save result
          (?!)                       # Try again
         /x;
    print Dumper \@matches ;
}

[download]

Namely if I use "my" instead it will return:

$VAR = [ # with something ]

# and then empty....

$VAR = [];
$VAR = []; 

etc...

[download]




---
neversaint and everlastingly indebted.......

I've been asked why I used a package variable instead of a lexical variable. It's because regexps close around the lexicals that exist when they are first run.

                                       # pass  1   2   3
                                       #      --- --- ---
sub test {
   my @matches;
   '' =~ /
      (?{ push @matches, 'a' })
      (?{ print(scalar(@matches), "\n") })   # 1   2   3
   /xg;  
   print(scalar(@matches), "\n");            # 1   0   0
}

test() for 1..3;
[download]

A variable called @matches is created everytime test is called. The regexp always uses the variable from the first call.

You can still do the same thing using lexicals (if you are allergic to using symbol-table variables). The only thing to be careful is to reuse the same push statement and same target array every time. This is adapted from the code in Re^3: Regexes: finding ALL matches (including overlap):

{
  my @matches;
  my $push = qr/(?{ push @matches, $1 })/;

  sub match_all_ways {
      my ($string, $regex) = @_;
      @matches = ();
      $string =~ m/($regex)$push(?!)/;
      return @matches;
  }
}

print match_all_ways( "TXXXABCDGXXXCCCDTGYYYCCCYYYCC", qr/XXX.*YYY/ );
[download]

Technically, $push is not needed -- you could just include (?{push @matches, $1}) in the m// statement inline. However, I like this way as it makes it a much more obvious that this part of the regex is only compiled once.

blokhead