C# Regex Atomic Opening and Closing Brackets

Question

I have the following which is a placeholder, I'm trying to use Atomic groups to catch double opening and closing brackets in pairs:

{{(?>{{(?)|}}(<-DEPTH>)|[^{}])*}}(?(DEPTH)(?!))

I am {{name}} and I have {{scales}: red {{metallic_scales}: shiny and glistering}} scales}}

Safe to say, I'm not really having much success.

So I'd want something like:

{{name}}
{{scales}: red {{metallic_scales}: shiny and glistering}} scales}}
{{metallic_scales}: shiny and glistering}}

I would suggest changing your approach, using a `Stack` instead of Regex — , Nov 24 '19 at 04:52
Check that https://docs.microsoft.com/en-us/dotnet/api/system.collections.stack, I also recommend that you search for balanced brackets implementations — , Nov 24 '19 at 05:01
Perhaps, but I'd like to use Regex if possible. I'll research what you provided tho, this seems a good thing to use. — Mathias Chartier, Nov 24 '19 at 05:05
The brackets opening and closing double are to determine when a grouping really close. Because you can do {{metallic_scales}: shiny and glistering|{chromatic_scales}: words}}. — Mathias Chartier, Nov 24 '19 at 05:21
Maybe that can help you https://www.regular-expressions.info/balancing.html — , Nov 24 '19 at 05:27
Also: https://stackoverflow.com/questions/546433/regular-expression-to-match-balanced-parentheses — , Nov 24 '19 at 05:30

score 0 · Accepted Answer · answered Nov 24 '19 at 12:09

You may use

(?=                    # Start of a positive lookahead to enable overlapping matches
  (?<results>          # The group storing the results
    {{                 # {{ (left-hand delimiter)
      (?>              # Start of an atomic group
        (?!{{|}}).|    # Any char not starting {{ or }} char sequence, or
        {{(?<DEPTH>)|  # {{ and a value pushed on to DEPTH group stack, or
        }}(?<-DEPTH>)  # }} and a value popped from the DEPTH group stack
      )*               # Zero or more repetitions of the atomic group patterns
    }}                 # }} substring
    (?(DEPTH)(?!))     # Conditional construct failing the match if DEPTH stack is not empty
  )                    # End of the results group
)                      # End of the lookahead

See the regex demo.

C# declaration:

Regex reg = new Regex(@"
    (?=                  # Start of a positive lookahead to enable overlapping matches
      (?<results>          # The group storing the results
        {{                 # {{ (left-hand delimiter)
          (?>              # Start of an atomic group
            (?!{{|}}).|    # Any char not starting {{ or }} char sequence, or
            {{(?<DEPTH>)|  # {{ and a value pushed on to DEPTH group stack, or
            }}(?<-DEPTH>)  # }} and a value popped from the DEPTH group stack
          )*               # Zero or more repetitions of the atomic group patterns
        }}                 # }} substring
        (?(DEPTH)(?!))     # Conditional construct failing the match if DEPTH stack is not empty
      )                    # End of the results group
    )                      # End of the lookahead", 
    RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline);
var results = reg.Matches(text).Cast<Match>().Select(x => x.Groups["results"].Value);

@MathiasChartier Glad it worked for you. Please consider also upvoting [if my answer proved helpful to you](https://stackoverflow.com/help/someone-answers). — Wiktor Stribiżew, Nov 28 '19 at 11:09

C# Regex Atomic Opening and Closing Brackets

1 Answers1