The simplest solution is to just remove the quantifier, and add a negative lookahead. Then the regex becomes:

    m[
      <%           # Opening delimiter.
      (?:  [^%]+   # Things that can't start one.
         | % (?!>) # % that aren't part of a closer
      )*           # As many non-closing-delims as you like.
      %>           # Closing delimiter.
    ]x
[download]

Backtracking no longer needed. (-:

    m[
      <%        # Opening delimiter.
      (?:       # Match stuff that isn't a closing delim:
        [^%]      # Can't start one.
      | %(?!>)    # Might start one but isn't one.
      )*        # As many non-closing-delims as you like.
      %>        # Closing delimiter.
    ]x
[download]

      (?:       # Match stuff that isn't a closing delim:
        [^%]+     # Things that can't start one.
      | %+[^>]    # Might start one but isn't one.
      )*
[download]

For it to behave properly, you should loose the plusses.

Thanks for all the replies, everyone. I had considered look-aheads but didn't want to go there because there is supposed to be a way to do this that works well and doesn't require these new regex features.

How would you get Perl 4 or sed to match C comments? I've read Mastering Regular Expressions but not recently and no longer have a copy.

I realize that the author doesn't like nesting of quantifiers like that. But avoiding the quantifiers also means that the outer construct has to match more times. Since Perl stops after that happens 32k times, the extra quantifier can make a real improvement. I prefer to prevent rampant back-tracking on failure by making the regex very explicit so that back-tracking won't happen. If I can't do that, then I consider solving the problem in smaller pieces.

                - tye

Alternate solutions. The simplest is to use a minimal match: m/<%.*?%>/s. However you can get by with basic features with something like: m/<%[^%]*(%+[^%>][^%]*)*%+>/. That should, possibly with appropriate syntax adjustments, work in any RE engine worthy of the name.

Making the (?: ) into a (?> ) should also fix that without removing the pluses, no?

Makeshifts last the longest.

Um, no.

$s = '1 <% xxx%%> 2 <%%> 3 <%>%> 4 <% >% %> 5 <%%%% xxx %%%%> 6 ';

$s =~ s/<% (?> [^%]+ | %+ [^>]+ )* %>/!REPLACED!/xg; 
print $s;

1 !REPLACED!%> 4 <% >% %> 5 <%%%% xxx %%%%> 6
[download]

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller

Perl is smarter than you think. It has a hack that mostly fixes this problem (and does in the above case).

I was looking for an old node of mine, and I came across this node again. I was bored, so I decided to work it out. First, the flow:

http://jryan.perlmonk.org/images/uloop.gif

A green node in this case means "that char", and a red node means "anything but that char". Green lines mean "yes", Red lines mean "no." So, we can directly translate that into the code:

    m[
      < %          # node 0 -> node 1 ->
      (            # node 0 -> node 1 -> node 2 (?) ->
         %         # node 0 -> node 1 -> node 2 (yes) ->
           (       # node 0 -> node 1 -> node 2 (yes) -> node 4 (?) ->
              [^>] # node 0 -> node 1 -> node 2 (yes) -> node 4 (no) -
+>
            | [^%] # node 0 -> node 1 -> node 2 (yes) -> node 4 (yes) 
+->
                   #                                     node 3 (?) ->
           ) 
       | [^%]      # node 0 -> node 1 -> node 2 (no)  -> node 3 (?) ->
      )*           # 
      (%)+         # node 5 (?)
      >            # node 5 (no) -> node 6
    ]x
[download]

And, Perl lets us condense that into:

    m[
      < %
      (?:
          [^%]+
        | % [^%>]
      )*
      %*          # I left it as %* so the "insides" can be easily
                  # grouped & captured
      % >
    ]x
[download]

So, your quick hack of a fix turns out to be the proper solution after all :)

The first one fails by not stopping soon enough for "<% %%> %>". The second fails by not matching "<% %% %>".

Thanks for the thoughts.

                - tye

Cribbing from Mastering Regular Expressions' section on removing C-style quotes ...

qr{
     <%
        [^%]*
        %+
        (
           [^>%]
           [^%]*
           %+
        )*
     >
  }x;
[download]

appears to properly handle every example in this thread, as well as not taking forever on a failed match.

Read more... (1162 Bytes)

---

Remember, when you stare long into the abyss, you could have been home eating ice cream.