How to create loop with regular expression?

Question

Honestly, I think I should first ask for your help with syntax of this question first.

But please if you can understand what I mean edit the title with suitable one.

Is there a way to make pattern that can split a text like this.

{{START}}
    {{START}}
        {{START}}
            {{START}}
            {{END}}
        {{END}}
    {{END}}
{{END}}

So every {{START}} matches its {{END}} from inside first to outside last!

And if I cannot do that with regex only. What about doing it using PHP?

Thank you up front.

Answer 1

This is beyond the capability of a regular expression, which can only parse regular grammars. What you're describing would require a pushdown automaton (regular languages are defined by a regular automaton).

You can use regular expression to parse the individual elements, but the "depth" part needs to be handled by a a language with a concept of memory (PHP is fine for this).

So in your solution, regexes will just be used for identifying your tags, while the real logic as to tracking depth and determining which element the END tag belongs to will must be your program itself.

Answer 2

It is possible! You can have each level of content using a recursive regular expression:

$data = <<<LOD
{{START1}}
    aaaaa
    {{START2}}
        bbbbb
        {{START3}}
            ccccc
            {{START4}}
                ddddd
            {{END4}}
        {{END3}}
    {{END2}}
{{END1}}
LOD;

$pattern = '~(?=({{START\d+}}(?>[^{]++|(?1))*{{END\d+}}))~';
preg_match_all ($pattern, $data, $matches);

print_r($matches);

explanations:

part: ({{START\d+}}(?>[^{]++|(?1))*{{END\d+}})

This part of the pattern describe a nested structure with {{START#}} and {{END#}}

(             # open the first capturing group
{{START\d+}}  
(?>           # open an atomic group (= backtracks forbidden)
    [^{]++    # all that is not a { one or more times (possessive)
  |           # OR
    (?1)      # refer to the first capturing group itself
)             # close the atomic group
{END\d+}}     # 
)             # close the first capturing group

Now the problem is that you can't capture all the level with this part only, because all the characters of the string are consumed by the pattern. In other words you can't match overlapped parts of the string.

The issue is to wrap all this part inside a zero-width assertion which doesn't consume characters like a lookahead (?=...), result:

(?=({{START\d+}}(?>[^{]++|(?1))*{{END\d+}}))

This will match all the levels.

Answer 3

You cannot do this with pure RegEx, however with a simple loop it can be accomplished.

JS Example:

//[.\s\S]* ensures line breaks are matched (dotall not supported in JS)
var exp = /\{\{START\}\}([.\s\S]*)\{\{END\}\}/;

var myString = "{{START}}\ntest\n{{START}}\ntest 2\n{{START}}\ntest 3\n{{START}}\ntest4\n{{END}}\n{{END}}\n{{END}}\n{{END}}";

var matches = [];
var m = exp.exec(myString);
while ( m != null ) {
    matches.push(m[0]);
    m = exp.exec(m[1]);
}

alert(matches.join("\n\n"));

PHP (I have no idea if this is correct, it's been forever since I've done PHP)

$pattern = "/\{\{START\}\}([.\s\S]*)\{\{END\}\}/";
$myString = "{{START}}\ntest\n{{START}}\ntest 2\n{{START}}\ntest 3\n{{START}}\ntest4\n{{END}}\n{{END}}\n{{END}}\n{{END}}";

$result = preg_match($pattern, $myString, $matches, PREG_OFFSET_CAPTURE);
$outMatches = array();
while ( $result ) {
    array_push($outMatches, $matches[0]);
    $result = preg_match($pattern, $matches[1], $matches, PREG_OFFSET_CAPTURE);
}
print($outMatches);

Output:

{{START}}
test
{{START}}
test 2
{{START}}
test 3
{{START}}
test4
{{END}}
{{END}}
{{END}}
{{END}}

{{START}}
test 2
{{START}}
test 3
{{START}}
test4
{{END}}
{{END}}
{{END}}

{{START}}
test 3
{{START}}
test4
{{END}}
{{END}}

{{START}}
test4
{{END}}