在 c 样式注释中读取 Python 正则表达式

Question

我试图在 c 文件中查找 c 样式的 cmets，但如果恰好在引号内有 //，我会遇到麻烦。这是文件：

/*My function
is great.*/
int j = 0//hello world
void foo(){
    //tricky example
    cout << "This // is // not a comment\n";
}

它将与该 cout 匹配。这是我目前所拥有的（我已经可以匹配 /**/ cmets）

fp = open(s)

p = re.compile(r'//(.+)')
txt = p.findall(fp.read())
print (txt)

Answer 1

第一步是确定不能将// 或/* 解释为注释子字符串开头的情况。例如，当它们位于字符串 （引号之间） 内时。为了避免引号（或其他东西）之间的内容，诀窍是将它们放在捕获组中并在替换模式中插入反向引用：

模式：

(
    "(?:[^"\\]|\\[\s\S])*"
  |
    '(?:[^'\\]|\\[\s\S])*'
)
|
//.*
|
/\*(?:[^*]|\*(?!/))*\*/

替换：

\1

online demo

由于引用的部分是最先搜索的，每次你找到// 或/*...*/，你可以确定你不在一个字符串中。

请注意，该模式是自愿低效的（由于(A|B)* 子模式）以使其更易于理解。为了提高效率，您可以像这样重写它：

("(?=((?:[^"\\]+|\\[\s\S])*))\2"|'(?=((?:[^'\\]+|\\[\s\S])*))\3')|//.*|/\*(?=((?:[^*]+|\*(?!/))*))\4\*/

(?=(something+))\1 只是模拟atomic group (?>something+) 的一种方式

online demo

所以，如果您只想找到 cmets（而不是删除它们），最方便的方法是将模式的 cmets 部分放在捕获组中并测试它是否不为空。 （在 Jonathan Leffler 评论之后） 对以下模式进行了修改，以处理被预处理器解释为反斜杠字符的三元组 ??/（我假设代码不是为-trigraphs option) 并处理后跟换行符的反斜杠，该换行符允许在多行中格式化单行：

fp = open(s)

p = re.compile(r'''(?x)
(?=["'/])      # trick to make it faster, a kind of anchor
(?:
    "(?=((?:[^"\\?]+|\?(?!\?/)|(?:\?\?/|\\)[\s\S])*))\1" # double quotes string
  |
    '(?=((?:[^'\\?]+|\?(?!\?/)|(?:\?\?/|\\)[\s\S])*))\2' # single quotes string
  |
    (
        /(?:(?:\?\?/|\\)\n)*/(?:.*(?:\?\?|\\)/\n)*.* # single line comment
      |
        /(?:(?:\?\?/|\\)\n)*\*                       # multiline comment
        (?=((?:[^*]+|\*+(?!(?:(?:\?\?/|\\)\n)*/))*))\4
        \*(?:(?:\?\?/|\\)\n)*/             
    )
)
''')

for m in p.findall(fp.read()):
    if (m[2]):    
        print m[2]

这些更改不会影响模式效率，因为正则表达式引擎的主要工作是查找以引号或斜杠开头的位置。通过在模式 (?=["'/]) 的开头存在一个前瞻来简化此任务，它允许内部优化以快速找到第一个字符。

另一个优化是使用模拟原子组，这将回溯减少到最小，并允许在重复组内使用贪婪量词。

注意：C 中可能没有heredoc 语法！

Answer 2

Python 的re.findall 方法基本上与大多数词法分析器的工作方式相同：它连续返回从前一个匹配完成的位置开始的最长匹配。所需要的只是产生所有词汇模式的析取：

(<pattern 1>)|(<pattern 2>)|...|(<pattern n>)

与大多数词法分析器不同，它不需要匹配是连续的，但这并不是一个显着的区别，因为您总是可以添加 (.) 作为最后一个模式，以便单独匹配所有其他不匹配的字符。

re.findall 的一个重要特性是，如果正则表达式有任何组，则只会返回组。因此，您可以通过简单地省略括号或将它们更改为非捕获括号来排除替代方案：

(<pattern 1>)|(?:<unimportant pattern 2>)|(<pattern 3)

考虑到这一点，让我们看看如何将 C 标记为足以识别 cmets。我们需要处理：

1. 单行cmets：// Comment
2. 多行cmets：/* Comment */
3. 双引号字符串："Might include escapes like \n"
4. 单引号字符：'\t'
5. （见下文，了解更多令人不快的案例）

考虑到这一点，让我们为上述每个创建正则表达式。

1. 两个斜杠后跟除换行符以外的任何内容：//[^\n]*
2. 这个正则表达式解释起来很乏味：/*[^*]*[*]+(?:[^/*][^*]*[*]+)*/ 请注意，它使用(?:...) 来避免捕获重复的组。
3. 引号，除引号和反斜杠之外的字符的任何重复，或反斜杠后跟任何字符。这不是转义序列的精确定义，但它足以检测 " 何时终止字符串，这是我们所关心的："(?:[^"\\]|\\.*)"
4. 与 (3) 相同，但带有单引号：'(?:[^'\\]|\\.)*'

最后，目标是找到 C 风格的 cmets 的文本。所以我们只需要避免在任何其他组中捕获。因此：

p = re.compile('|'.join((r"(//[^\n])*"
                        ,r"/*[^*]*[*]+(?:[^/*][^*]*[*]+)*/"
                        ,'"'+r"""(?:[^"\\]|\\.)*"""+'"'
                        ,r"'(?:[^'\\]|\\.)*'")))
return [c[2:] for c in p.findall(text) if c]

---

上面，我省略了一些不太可能出现的模糊案例：

1. 在#include <...> 指令中，<...> 本质上是一个字符串。理论上，它可以包含看起来像 cmets 的引号或序列，但实际上你永远不会看到：

   #include </*This looks like a comment but it is a filename*/>
   

2. 以 \ 结尾的行在下一行继续； \ 和后面的换行符只是从输入中删除。这发生在任何词法扫描之前，因此以下是完全合法的注释（实际上是两个 cmets）：

   /\
   **************** Surprise! **************\
   //////////////////////////////////////////
   

3. 更糟糕的是，三元组??/ 与 \ 相同，并且替换发生在继续处理之前。

   /************************************//??/
   **************** Surprise! ************??/
   //////////////////////////////////////////
   

   在混淆竞赛之外，没有人真正使用三元组。但它们仍然符合标准。处理这两个问题的最简单方法是预扫描字符串：

   return [c[2:]
           for c in p.findall(text.replace('//?','\\').replace('\\\n',''))
           if c]
   

处理#include <...> 问题的唯一方法是，如果您真的关心它，那就是再添加一个模式，例如#define\s*<[^>\n]*>。