Home/ Questions/Q 7672229
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-31T16:14:16+00:00

i know there are several questions about regex recursion in .net. I can write

  • 0

i know there are several questions about regex recursion in .net. I can write somewhat complex regex expressions but this recursion is beyond me, i am just not able to write it.

This are the questions closest to what i want.

first question, second question.

but it matches the entire string, i want the matches in a collection preferably the innermost match first or in some order. Also it matches on one opening character and one closing character. Mine is 2 chars for opening and closing, [! and !]

my input string will be something like this.

[!a='test' b='[!a='innertest' b='innervalue'!]'!]

I need to find the innertest section, [!a='innertest' b='innervalue'!], first and then evaluate it through one of my expression trees. then evaluate the parent one containing it.

Can anyone help with this?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Here’s a pattern that might satisfy your needs:

    ^\[!((?<n>\w+='\[!)|(?<inner-n>!]')|\w+='(?!\[!)[^']*'| )*!](?!(n))$

    It will give the innermost item for each item in order. To explain what I mean, given the code:

    [!a='test' c='[!x='blah'!]' b='[!a='[!y='innermost'!]' b='innervalue'!]' !]

    It will give the following matches (in the capture collection for the group “inner”):

    x='blag'
y='innermost'
a='[!y='innermost'!]' b='innervalue'

    So, for each x=y item in the [! .. !], it will give the matches in order from innermost outwards.

    If you also want the overall expression to be captured you can modify it like this:

    ^(?<n>\[!)((?<n>\w+='\[!)|(?<inner-n>!]')|\w+='(?!\[!)[^']*'| )*(?<inner-n>!])(?!(n))$

    Giving:

    x='blag'
y='innermost'
a='[!y='innermost'!]' b='innervalue'
a='test' c='[!x='blag'!]' b='[!a='[!y='innermost'!]' b='innervalue'!]'

    And to explain the regex:

    ^       # start of string
\[!     # start of overall [! .. !]
(       # either ...
    (?<n>\w+='\[!)|     # a complex x='[! .. !]' containing a nested [! .. !] - push this onto the stack 'n'
    (?<inner-n>!]')|    # end of a nested [! .. !] - pop stack 'n', and capture the contents into 'inner'
    \w+='(?!\[!)[^']*'| # a simple x='asdf' with no nested [! .. !]
     )                  # or a space
*       # as many times as you want
!]      # the end of the overall [! .. !]
(?!(n)) # assert that the 'n' stack is empty, no mismatched [! .. !]
$       # end of string
    • 0