What class of languages do real modern regexes actually recognise?
Whenever there is an unbounded length capturing group with a back-reference (e.g. (.*)_\1) a regex is now matching a non-regular language. But this, on its own, isn’t enough to match something like S ::= '(' S ')' | ε — the context-free language of matching pairs of parens.
Recursive regexes (which are new to me, but I am assured exist in Perl and PCRE) appear to recognize at least most CFLs.
Has anyone done or read any research in this area? What are the limitations of these “modern” regexes? Do they recognize strictly more or strictly less than CFGs, of LL or LR grammars? Or do there exist both languages that can be recognized by a regex but not a CFG and the opposite?
Links to relevant papers would be much appreciated.
Pattern Recursion
With recursive patterns, you have a form of recursive descent matching.
This is fine for a variety of problems, but once you want to actually do recursive descent parsing, you need to insert capture groups here and there, and it is awkward to recover the full parse structure in this way. Damian Conway’s Regexp::Grammars module for Perl transforms the simple pattern into an equivalent one that automatically does all that named capturing into a recursive data structure, making for far easier retrieval of the parsed structure. I have a sample comparing these two approaches at end of this posting.
Restrictions on Recursion
The question was what kinds of grammars that recursive patterns can match. Well, they’re certainly recursive descent type matchers. The only thing that comes to mind is that recursive patterns cannot handle left recursion. This puts a constraint on the sorts of grammars that you can apply them to. Sometimes you can reorder your productions to eliminate left recursion.
BTW, PCRE and Perl differ slightly on how you’re allowed to phrase the recursion. See the sections on “RECURSIVE PATTERNS” and “Recursion difference from Perl” in the pcrepattern manpage. eg: Perl can handle
^(.|(.)(?1)\2)$where PCRE requires^((.)(?1)\2|.)$instead.Recursion Demos
The need for recursive patterns arises surprisingly frequently. One well-visited example is when you need to match something that can nest, such as balanced parentheses, quotes, or even HTML/XML tags. Here’s the match for balenced parens:
I find that trickier to read because of its compact nature. This is easily curable with
/xmode to make whitespace no longer significant:Then again, since we’re using parens for our recursion, a clearer example would be matching nested single quotes:
Another recursively defined thing you may wish to match would be a palindrome. This simple pattern works in Perl:
which you can test on most systems using something like this:
Note that PCRE’s implementation of recursion requires the more elaborate
This is because of restrictions on how PCRE recursion works.
Proper Parsing
To me, the examples above are mostly toy matches, not all that interesting, really. When it becomes interesting is when you have a real grammar you’re trying to parse. For example, RFC 5322 defines a mail address rather elaborately. Here’s a “grammatical” pattern to match it:
As you see, that’s very BNF-like. The problem is it is just a match, not a capture. And you really don’t want to just surround the whole thing with capturing parens because that doesn’t tell you which production matched which part. Using the previously mentioned Regexp::Grammars module, we can.
As you see, by using a very slightly different notation in the pattern, you now get something which stores the entire parse tree away for you in the
%/variable, with everything neatly labelled. The result of the transformation is still a pattern, as you can see by the=~operator. It’s just a bit magical.