C# regular expression for finding forms with input tags in HTML?

Question

Hi all. I have a simple problem: I want to construct a regex that matches a form in HTML, but only if the form has any input tags. Example:

The following should be matched (ignoring attributes):

..
<form>
..
<input/>
..
</form>
..

But the following should not (ignoring attributes):

..
<form>
..
</form>
..

I have tried everything from look-arounds to capture groups but it quickly gets complicated. I want to believe there is a simple regex to capture the problem. Please note that it is important that the regex pairs the opening and closing tags according to the HTML code which means the following does not work:

<form>.+<input/>.+</form>

because it matches wrongly like this:

..
<form> <--- This is wrongly matched as the opening tag 
..
</form> 
<form> <-- This is the correct opening tag of the correct form
..
<input/>
..
</form> <--- This is matched as the closing tag
..

EDIT:

I already made a RegEx that matches what I want; my question is now how to do it, but how to do it SIMPLE/elegantly. To me this is not simple or elegant at all:

<form>
(.(?<!</form>))+
<input/>
(.(?<!</form>))+
</form>

Answer 1

Don't parse HTML with regular expressions.

Answer 2

You really don't want to parse HTML using RegEx. See this answer if you need more convicing.

Regular expressions are the wrong tool for trying to parse HTML - especially when it's HTML that is not gauranteed to be well formed.

You should really get an HTML/XHTML parsing library and use that to match HTML content. Take a look at the HTML Agility Pack, it's probably sufficient for what you need.

Answer 3

You should not parse HTML with regular expressions, but if you must, then what about something simple as:

<form>[^</form>]+<input/>.+</form>

Answer 4

I want to believe there is a simple regex to capture the problem

Wishing does not make it so. There is no evidence for the proposition that every problem can be solved with regular expressions, and plenty of evidence against. Your faith is not well placed.

The set of languages which are recognizable by regular expressions is called -- unsurprisingly -- the regular languages. A nice property of all regular languages is that they can be recognized by a device with finitely many states. Therefore, you can quickly figure out if a language is not regular by asking yourself the question "would I require an unbounded number of states to recognize this language?"

Consider the language of matching parens: (), ()(), (()), ()(()), and so on. To recognize this language you have to keep track of how many open parens there are waiting to be closed, and therefore you need an unbounded number of states. Therefore this language is not a regular language, and therefore it cannot be matched by a regular expression.

HTML is clearly the paren language but even more complicated, because now there are an infinite number of different "kinds of parens". Each tag is like an open paren that must be matched by its corresponding closing tag. Since this is an even more complex and difficult version of a non-regular language, clearly it cannot be a regular language. And therefore it cannot be matched correctly with regular expressions.

The right tool to recognize patterns in HTML is an HTML parser.