“现代”正则表达式的识别能力

83

真正的现代正则表达式实际上可以识别哪种语言？

每当有一个带有后向引用（例如(.*)_\1）的无限长度捕获组时，正则表达式现在就会与非常规语言匹配。但是，仅凭它本身还不足以匹配类似的东西S ::= '(' S ')' | ε-匹配配对对的上下文无关语言。

递归正则表达式（对我来说是新的，但我确信Perl和PCRE中存在）可以识别至少大多数CFL。

有没有人做过或读过这方面的研究？这些“现代”正则表达式的局限性是什么？他们对LL或LR语法的认识比CFG严格多还是少？还是存在两种可以被正则表达式识别但CFG不能识别的语言，而相反呢？

与相关论文的链接将不胜感激。

regex  perl  theory  context-free-grammar  language-theory 
— Tobyodavies
source
1
我不知道关于递归模式可解决的问题的可计算性类别的任何正式工作。我确实知道您上面的递归生成很容易被编码为PCRE或Perl中的递归模式。
— tchrist 2011年
5
这会更适合cstheory.stackexchange.com吗？
— arcain 2011年
3
@arcain，我真的不认为这是一个“研究水平的问题”，因为它可能已经死了……如果我什么也没听到，我可能会尝试将其张贴在这里……
— tobyodavies
2
@toby-当然，但这是一个理论问题，cstheory的社区是一个更加专业的听众。交易量也较低，因此，您的问题在容易回答的问题中泛滥的可能性就很小。我只想看看您的问题得到答案。
— arcain 2011年
2
旧帖子，但我已经多次提及此链接：nikic.github.io/2012/06/15/…–
— Anders

Answers:

106

模式递归

使用递归模式，您将具有递归下降匹配的形式。

这对于各种问题都很好，但是一旦您要实际执行递归下降解析，就需要在各处插入捕获组，以这种方式恢复完整的解析结构很尴尬。Damian Conway的Perl Regexp :: Grammars模块将简单模式转换为等效模式，该模式自动将所有名为“捕获”的操作转换为递归数据结构，从而使解析结构的检索更加容易。在本文的结尾，我有一个示例比较了这两种方法。

递归限制

问题是递归模式可以匹配哪些语法。好吧，它们肯定是递归下降型匹配器。唯一想到的是递归模式无法处理左递归。这对可以应用它们的语法构成了限制。有时，您可以对生产进行重新排序以消除左递归。

BTW，PCRE和Perl在允许使用递归的方式上略有不同。请参见pcrepattern联机帮助页中的“递归模式”和“与Perl的递归差异”部分。例如：Perl可以处理^(.|(.)(?1)\2)$PCRE需要的地方^((.)(?1)\2|.)$。

递归演示

递归模式的需求令人惊讶地频繁出现。一个广为人知的示例是，当您需要匹配一些可以嵌套的内容时，例如平衡的括号，引号甚至HTML / XML标签。这是平衡的parens的匹配项：

\((?:[^()]*+|(?0))*\)

由于其紧凑的性质，我觉得阅读起来比较棘手。使用/xmode可以轻松解决此问题，以使空格不再有意义：

\( (?: [^()] *+ | (?0) )* \)

再说一次，由于我们使用parens进行递归，一个更清晰的例子是匹配嵌套的单引号：

‘ (?: [^‘’] *+ | (?0) )* ’

您可能希望匹配的另一种递归定义的东西是回文。这个简单的模式在Perl中有效：

^((.)(?1)\2|.?)$

您可以使用以下方法在大多数系统上进行测试：

$ perl -nle 'print if /^((.)(?1)\2|.?)$/i' /usr/share/dict/words

请注意，PCRE递归的实现需要更详尽的说明

^(?:((.)(?1)\2|)|((.)(?3)\4|.))

这是因为PCRE递归的工作方式受到限制。

正确解析

对我来说，上面的例子大多是玩具比赛，不是所有的这有趣的，真的。当它变得有趣时，就是您要尝试解析一个真实的语法。例如，RFC 5322相当详细地定义了一个邮件地址。这是一个与之匹配的“语法”模式：

$rfc5322 = qr{

   (?(DEFINE)

     (?<address>         (?&mailbox) | (?&group))
     (?<mailbox>         (?&name_addr) | (?&addr_spec))
     (?<name_addr>       (?&display_name)? (?&angle_addr))
     (?<angle_addr>      (?&CFWS)? < (?&addr_spec) > (?&CFWS)?)
     (?<group>           (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ; (?&CFWS)?)
     (?<display_name>    (?&phrase))
     (?<mailbox_list>    (?&mailbox) (?: , (?&mailbox))*)

     (?<addr_spec>       (?&local_part) \@ (?&domain))
     (?<local_part>      (?&dot_atom) | (?&quoted_string))
     (?<domain>          (?&dot_atom) | (?&domain_literal))
     (?<domain_literal>  (?&CFWS)? \[ (?: (?&FWS)? (?&dcontent))* (?&FWS)?
                                   \] (?&CFWS)?)
     (?<dcontent>        (?&dtext) | (?&quoted_pair))
     (?<dtext>           (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e])

     (?<atext>           (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~])
     (?<atom>            (?&CFWS)? (?&atext)+ (?&CFWS)?)
     (?<dot_atom>        (?&CFWS)? (?&dot_atom_text) (?&CFWS)?)
     (?<dot_atom_text>   (?&atext)+ (?: \. (?&atext)+)*)

     (?<text>            [\x01-\x09\x0b\x0c\x0e-\x7f])
     (?<quoted_pair>     \\ (?&text))

     (?<qtext>           (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e])
     (?<qcontent>        (?&qtext) | (?&quoted_pair))
     (?<quoted_string>   (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))*
                          (?&FWS)? (?&DQUOTE) (?&CFWS)?)

     (?<word>            (?&atom) | (?&quoted_string))
     (?<phrase>          (?&word)+)

     # Folding white space
     (?<FWS>             (?: (?&WSP)* (?&CRLF))? (?&WSP)+)
     (?<ctext>           (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e])
     (?<ccontent>        (?&ctext) | (?&quoted_pair) | (?&comment))
     (?<comment>         \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) )
     (?<CFWS>            (?: (?&FWS)? (?&comment))*
                         (?: (?:(?&FWS)? (?&comment)) | (?&FWS)))

     # No whitespace control
     (?<NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f])

     (?<ALPHA>           [A-Za-z])
     (?<DIGIT>           [0-9])
     (?<CRLF>            \x0d \x0a)
     (?<DQUOTE>          ")
     (?<WSP>             [\x20\x09])
   )

   (?&address)

}x;

如您所见，这非常类似于BNF。问题在于这只是一场比赛，而不是一场比赛。而且，您确实不希望只用捕获paren来包围整个事情，因为这并不能告诉您哪个产品与哪个部分匹配。使用前面提到的Regexp :: Grammars模块，我们可以。 

#!/usr/bin/env perl

use strict;
use warnings;
use 5.010;
use Data::Dumper "Dumper";

my $rfc5322 = do {
    use Regexp::Grammars;    # ...the magic is lexically scoped
    qr{

    # Keep the big stick handy, just in case...
    # <debug:on>

    # Match this...
    <address>

    # As defined by these...
    <token: address>         <mailbox> | <group>
    <token: mailbox>         <name_addr> | <addr_spec>
    <token: name_addr>       <display_name>? <angle_addr>
    <token: angle_addr>      <CFWS>? \< <addr_spec> \> <CFWS>?
    <token: group>           <display_name> : (?:<mailbox_list> | <CFWS>)? ; <CFWS>?
    <token: display_name>    <phrase>
    <token: mailbox_list>    <[mailbox]> ** (,)

    <token: addr_spec>       <local_part> \@ <domain>
    <token: local_part>      <dot_atom> | <quoted_string>
    <token: domain>          <dot_atom> | <domain_literal>
    <token: domain_literal>  <CFWS>? \[ (?: <FWS>? <[dcontent]>)* <FWS>?

    <token: dcontent>        <dtext> | <quoted_pair>
    <token: dtext>           <.NO_WS_CTL> | [\x21-\x5a\x5e-\x7e]

    <token: atext>           <.ALPHA> | <.DIGIT> | [!#\$%&'*+-/=?^_`{|}~]
    <token: atom>            <.CFWS>? <.atext>+ <.CFWS>?
    <token: dot_atom>        <.CFWS>? <.dot_atom_text> <.CFWS>?
    <token: dot_atom_text>   <.atext>+ (?: \. <.atext>+)*

    <token: text>            [\x01-\x09\x0b\x0c\x0e-\x7f]
    <token: quoted_pair>     \\ <.text>

    <token: qtext>           <.NO_WS_CTL> | [\x21\x23-\x5b\x5d-\x7e]
    <token: qcontent>        <.qtext> | <.quoted_pair>
    <token: quoted_string>   <.CFWS>? <.DQUOTE> (?:<.FWS>? <.qcontent>)*
                             <.FWS>? <.DQUOTE> <.CFWS>?

    <token: word>            <.atom> | <.quoted_string>
    <token: phrase>          <.word>+

    # Folding white space
    <token: FWS>             (?: <.WSP>* <.CRLF>)? <.WSP>+
    <token: ctext>           <.NO_WS_CTL> | [\x21-\x27\x2a-\x5b\x5d-\x7e]
    <token: ccontent>        <.ctext> | <.quoted_pair> | <.comment>
    <token: comment>         \( (?: <.FWS>? <.ccontent>)* <.FWS>? \)
    <token: CFWS>            (?: <.FWS>? <.comment>)*
                             (?: (?:<.FWS>? <.comment>) | <.FWS>)

    # No whitespace control
    <token: NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f]
    <token: ALPHA>           [A-Za-z]
    <token: DIGIT>           [0-9]
    <token: CRLF>            \x0d \x0a
    <token: DQUOTE>          "
    <token: WSP>             [\x20\x09]
    }x;
};

while (my $input = <>) {
    if ($input =~ $rfc5322) {
        say Dumper \%/;       # ...the parse tree of any successful match
                              # appears in this punctuation variable
    }
}

如您所见，通过在模式中使用略有不同的表示法，您现在可以得到一些内容，该%/变量将整个解析树存储在变量中，并且所有内容都被整齐地标记。正如=~操作员所看到的，转换的结果仍然是一种模式。有点神奇。

— 基督
source
2
左递归的限制绝对值得了解，但是如果我没记错的话，它对严格的“识别能力”没有任何影响，因为对于任何左递归语法，都有一个右递归语法与之匹配语言-可能会更麻烦。
— hobbs
7
@tobyodavies：我本来可以进一步解释PCRE限制；它们与组的原子性有关：您不能在PCRE中尚未完成的组上调用递归，但在Perl中可以。语法RFC 5322模式在PCRE中应同样有效；整个((DEFINE)…)想法非常强大和有用，就像所有自上而下的编程一样，允许将声明（及其顺序）与执行分开。我不记得还有哪些其他语言具有组递归；它可能像C♯或类似的东西。
— tchrist 2011年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.