Hm, this will be very difficult to do in a single regexp. The non-overlapping requirement is similar to the problem of Matching C-style comments. Plus all those .*? are going to make the regex engine go nuts.

A real-live parser would probably be much easier for this. Take a look at Parse::RecDescent, or Parse::Yapp if you're already familiar with YACC/Bison.

"start b2 start b2 end start b2 b2 end"

then the only way I see to do it would be to use functions like index and substr to iterate over the string removing pieces of it until it is in the form you want before regex'ing it.

If on the slight chance you will always see a start marker, some text that does NOT include another start marker, and then an end marker, you can simply do this:

my $str = "start b2 end start b2 b2 end start b2 end";
if ($str =~ /.*start((.*?b2.*?b2).*?)end/) {
 print "$1 is between \"start\" and \"end\"\n";
}
[download]

Limbic~Region, thanks and I think that the solution you provided will work the best. I don't know why I didn't think of using the ".*" at the beginning of the string before to make it match minimally over "start .. end". Thanks for all of the help!

After taking another look, I think that the original reason why I wanted to use lookahead expressions was that the "start ... end" strings may be nested, as in the example provided by Limbic~Region. It looks like I'll need to use looping and string manipulation in place of a single regular expression. *sigh*

Doesn't always work:

my $str = "start b2 end start b2 end start b2 end";
#only one b2 between each start and end
if ($str =~ /.*start((.*?b2.*?b2).*?)end/) {
 print "$1\n";
}
__END__
Output:

 b2 end start b2
[download]

shouldn't match when there is only one 'b2' between start and end, but it does.

IMO, the most robust solution is to use a parser (Parse::RecDescent) or multiple regexes.

If you just want to check if the string matches, Limbic~Regions example will probably do it.

Although you didn't say it, I suppose you want to catch the substrings between 'start' and 'end' - otherwise you don't have to care about overlapping. In that case you could do something like the following:

#!usr/bin/perl
use warnings;
$_ = "start b2 end start b2 b2 end start b2 end";

@Matches = /        # list context to catch all
  (?<= \b start \b )# 'start' must precede
  ( .*? )           # catch fewest possible anythings
  (?=  \b end   \b )# 'end' must follow
/gx                 # global and expressive

and print join("\n", @Matches);

__DATA__
 b2 
 b2 b2 
 b2
[download]

update: normal matching without look-ahead and look-behind will have the same effect with the example string:

@Matches = /
  \b start \b
  ( .*? )
  \b end   \b
/gx
[download]

update: I overlooked that Limbic~Regions regex catches the substring too. Shame on me!

^~Django
"Why don't we ever challenge the spherical earth theory?"

Um, my RegEx does catch the substring between "start" and "end" as depicted in the print statment. As always, TIMTOWTDI.