Question

I came across a parsing problem, which would take a quite small regular expression to solve, except that the pattern to work, it should be recursive.
Example:

{([^{}]*(?:{(?1)})?)

What I want it to match, is a specific RTF header, but to do that, I need it to be recursive.

{\rtf1\ansi\ansicpg1252\deff0\deflang1031{\fonttbl{\f0\fnil\fcharset0 Tahoma;}}

Is there some kind of non-true RegEx-like engine implementation for .NET which would allow to find matches to these kinds of patterns (maybe even a different syntax)?

Update:

I do really appreciate everyone for informing me about the Balancing Group option in .NET implementation of Regular Expressions, especially Qtax, who has provided a very comprehensive link as a comment below, which helped me understand what’s this all about, and also for posting an answer to my specific example. If you are reading this, and it also helped you, be sure to upvote that answer.
However… That did not answer the general question about recursion possibility in .NET Regex-like engine. This example, fortunately (I like challenges) is by far not the only one I’ve met. And other situations can’t be solved using this solution, but only by being able to reference not a match, but to reuse a sequence of a pattern, to a point where recursion would be possible.

Answer 1

For your example using a balancing group would work.

You could use an expression like:

{
[^{}]*
(?:({)[^{}]*)*
(?'-1'})*
(?(1)(?!))
}

Example:

string re = @"{[^{}]*(?:({)[^{}]*)*(?'-1'})*(?(1)(?!))}";
string str = "foo {bar} baz {foo{bar{baz}}} {f{o{o}}{bar}baz} {foo{bar}baz}";

Console.WriteLine("Input: \"{0}\"", str);
foreach (Match m in Regex.Matches(str, re))
{
    Console.WriteLine("Match: \"{0}\"", m);
}

Output:

Input: "foo {bar} baz {foo{bar{baz}}} {f{o{o}}{bar}baz} {foo{bar}baz}"
Match: "{bar}"
Match: "{foo{bar{baz}}}"
Match: "{o{o}}"
Match: "{bar}"
Match: "{bar}"