对源文件进行词法分析是正则表达式的好工作。但是对于这样的任务，让我们使用比std::regex 更好的正则表达式引擎。我们首先使用 PCRE（或boost::regex）。在这篇文章的最后，我将展示使用功能较少的引擎可以做什么。
我们只需要进行部分词法分析，忽略所有不会影响字符串文字的无法识别的标记。我们需要处理的是：
- 单行 cmets
- 多行 cmets
- 字符字面量
- 字符串字面量
我们将使用扩展的 (x) 选项，它会忽略模式中的空格。
评论
[lex.comment] 是这样说的：
字符/* 开始注释，注释以字符*/ 结束。这些 cmets 不筑巢。
字符// 开始一个注释，它在下一个换行符之前立即终止。如果
此类评论中有换页符或垂直制表符，只能出现空白字符
在它和终止注释的换行符之间；不需要诊断。 [注：评论
字符 //、/* 和 */ 在 // 注释中没有特殊含义，并且与其他字符一样对待
人物。同样，注释字符// 和/* 在/* 注释中没有特殊含义。
——结束注]
# singleline comment
// .* (*SKIP)(*FAIL)
# multiline comment
| /\* (?s: .*? ) \*/ (*SKIP)(*FAIL)
简单易懂。如果你在那里匹配任何东西，只需(*SKIP)(*FAIL) - 这意味着你扔掉了匹配。 (?s: .*? ) 将s（单行）修饰符应用于. 元字符，这意味着它可以匹配换行符。
字符字面量
这是来自[lex.ccon]的语法：
character-literal:
encoding-prefix(opt) ’ c-char-sequence ’
encoding-prefix:
one of u8 u U L
c-char-sequence:
c-char
c-char-sequence c-char
c-char:
any member of the source character set except the single-quote ’, backslash \, or new-line character
escape-sequence
universal-character-name
escape-sequence:
simple-escape-sequence
octal-escape-sequence
hexadecimal-escape-sequence
simple-escape-sequence: one of \’ \" \? \\ \a \b \f \n \r \t \v
octal-escape-sequence:
\ octal-digit
\ octal-digit octal-digit
\ octal-digit octal-digit octal-digit
hexadecimal-escape-sequence:
\x hexadecimal-digit
hexadecimal-escape-sequence hexadecimal-digit
让我们先定义一些东西，我们稍后会用到：
(?(DEFINE)
(?<prefix> (?:u8?|U|L)? )
(?<escape> \\ (?:
['"?\\abfnrtv] # simple escape
| [0-7]{1,3} # octal escape
| x [0-9a-fA-F]{1,2} # hex escape
| u [0-9a-fA-F]{4} # universal character name
| U [0-9a-fA-F]{8} # universal character name
))
)
-
prefix 定义为可选的u8、u、U 或L
-
escape 是按照标准定义的，只是为了简单起见，我将 universal-character-name 合并到其中
一旦我们有了这些，字符文字就非常简单了：
(?&prefix) ' (?> (?&escape) | [^'\\\r\n]+ )+ ' (*SKIP)(*FAIL)
我们用(*SKIP)(*FAIL)把它扔掉
简单字符串
它们的定义方式几乎与字符文字相同。这是[lex.string]的一部分：
string-literal:
encoding-prefix(opt) " s-char-sequence(opt) "
encoding-prefix(opt) R raw-string
s-char-sequence:
s-char
s-char-sequence s-char
s-char:
any member of the source character set except the double-quote ", backslash \, or new-line character
escape-sequence
universal-character-name
这将反映字符文字：
(?&prefix) " (?> (?&escape) | [^"\\\r\n]+ )* "
区别在于：
- 这次字符序列是可选的（
* 而不是+）
- 未转义时不允许使用双引号而不是单引号
- 我们实际上不会把它扔掉:)
原始字符串
这是原始字符串部分：
raw-string:
" d-char-sequence(opt) ( r-char-sequence(opt) ) d-char-sequence(opt) "
r-char-sequence:
r-char
r-char-sequence r-char
r-char:
any member of the source character set, except a right parenthesis )
followed by the initial d-char-sequence (which may be empty) followed by a double quote ".
d-char-sequence:
d-char
d-char-sequence d-char
d-char:
any member of the basic source character set except:
space, the left parenthesis (, the right parenthesis ), the backslash \,
and the control characters representing horizontal tab,
vertical tab, form feed, and newline.
这个的正则表达式是：
(?&prefix) R " (?<delimiter>[^ ()\\\t\x0B\r\n]*) \( (?s:.*?) \) \k<delimiter> "
-
[^ ()\\\t\x0B\r\n]* 是分隔符中允许的字符集 (d-char)
-
\k<delimiter> 指的是之前匹配的分隔符
完整模式
完整的模式是：
(?(DEFINE)
(?<prefix> (?:u8?|U|L)? )
(?<escape> \\ (?:
['"?\\abfnrtv] # simple escape
| [0-7]{1,3} # octal escape
| x [0-9a-fA-F]{1,2} # hex escape
| u [0-9a-fA-F]{4} # universal character name
| U [0-9a-fA-F]{8} # universal character name
))
)
# singleline comment
// .* (*SKIP)(*FAIL)
# multiline comment
| /\* (?s: .*? ) \*/ (*SKIP)(*FAIL)
# character literal
| (?&prefix) ' (?> (?&escape) | [^'\\\r\n]+ )+ ' (*SKIP)(*FAIL)
# standard string
| (?&prefix) " (?> (?&escape) | [^"\\\r\n]+ )* "
# raw string
| (?&prefix) R " (?<delimiter>[^ ()\\\t\x0B\r\n]*) \( (?s:.*?) \) \k<delimiter> "
见the demo here。
boost::regex
这是一个使用boost::regex的简单演示程序：
#include <string>
#include <iostream>
#include <boost/regex.hpp>
static void test()
{
boost::regex re(R"regex(
(?(DEFINE)
(?<prefix> (?:u8?|U|L) )
(?<escape> \\ (?:
['"?\\abfnrtv] # simple escape
| [0-7]{1,3} # octal escape
| x [0-9a-fA-F]{1,2} # hex escape
| u [0-9a-fA-F]{4} # universal character name
| U [0-9a-fA-F]{8} # universal character name
))
)
# singleline comment
// .* (*SKIP)(*FAIL)
# multiline comment
| /\* (?s: .*? ) \*/ (*SKIP)(*FAIL)
# character literal
| (?&prefix)? ' (?> (?&escape) | [^'\\\r\n]+ )+ ' (*SKIP)(*FAIL)
# standard string
| (?&prefix)? " (?> (?&escape) | [^"\\\r\n]+ )* "
# raw string
| (?&prefix)? R " (?<delimiter>[^ ()\\\t\x0B\r\n]*) \( (?s:.*?) \) \k<delimiter> "
)regex", boost::regex::perl | boost::regex::no_mod_s | boost::regex::mod_x | boost::regex::optimize);
std::string subject(R"subject(
std::cout << L"hello" << " world";
std::cout << "He said: \"bananas\"" << "...";
std::cout << "";
std::cout << "\x12\23\x34";
std::cout << u8R"hello(this"is\a\""""single\\(valid)"
raw string literal)hello";
"" // empty string
'"' // character literal
// this is "a string literal" in a comment
/* this is
"also inside"
//a comment */
// and this /*
"is not in a comment"
// */
"this is a /* string */ with nested // comments"
)subject");
std::cout << boost::regex_replace(subject, re, "String\\($&\\)", boost::format_all) << std::endl;
}
int main(int argc, char **argv)
{
try
{
test();
}
catch(std::exception ex)
{
std::cerr << ex.what() << std::endl;
}
return 0;
}
（我禁用了语法高亮，因为这段代码太疯狂了）
出于某种原因，我不得不将? 量词从prefix 中取出（将(?<prefix> (?:u8?|U|L)? ) 更改为(?<prefix> (?:u8?|U|L) ) 并将(?&prefix) 更改为(?&prefix)?）以使模式起作用。我相信这是 boost::regex 中的一个错误，因为 PCRE 和 Perl 在原始模式下都可以正常工作。
如果我们手头没有花哨的正则表达式引擎怎么办？
请注意，虽然此模式在技术上使用递归，但它从不嵌套递归调用。可以通过将相关的可重用部分内联到主模式中来避免递归。
可以以降低性能为代价来避免其他一些构造。如果我们不嵌套量词以避免catastrophic backtracking，我们可以安全地将原子组(?>...) 替换为普通组(?:...)。
如果我们在替换函数中添加一行逻辑，我们也可以避免(*SKIP)(*FAIL)：所有要跳过的替代项都分组在一个捕获组中。如果捕获组匹配，则忽略匹配。如果不是，那么它是一个字符串文字。
所有这一切意味着我们可以在 JavaScript 中实现这一点，它具有您能找到的最简单的正则表达式引擎之一，但代价是打破 DRY 规则并使模式难以辨认。正则表达式一旦转换就变成了这个怪物：
(\/\/.*|\/\*[\s\S]*?\*\/|(?:u8?|U|L)?'(?:\\(?:['"?\\abfnrtv]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})|[^'\\\r\n])+')|(?:u8?|U|L)?"(?:\\(?:['"?\\abfnrtv]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})|[^"\\\r\n])*"|(?:u8?|U|L)?R"([^ ()\\\t\x0B\r\n]*)\([\s\S]*?\)\2"
这是一个您可以玩的交互式演示：
function run() {
var re = /(\/\/.*|\/\*[\s\S]*?\*\/|(?:u8?|U|L)?'(?:\\(?:['"?\\abfnrtv]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})|[^'\\\r\n])+')|(?:u8?|U|L)?"(?:\\(?:['"?\\abfnrtv]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})|[^"\\\r\n])*"|(?:u8?|U|L)?R"([^ ()\\\t\x0B\r\n]*)\([\s\S]*?\)\2"/g;
var input = document.getElementById("input").value;
var output = input.replace(re, function(m, ignore) {
return ignore ? m : "String(" + m + ")";
});
document.getElementById("output").innerText = output;
}
document.getElementById("input").addEventListener("input", run);
run();
<h2>Input:</h2>
<textarea id="input" style="width: 100%; height: 50px;">
std::cout << L"hello" << " world";
std::cout << "He said: \"bananas\"" << "...";
std::cout << "";
std::cout << "\x12\23\x34";
std::cout << u8R"hello(this"is\a\""""single\\(valid)"
raw string literal)hello";
"" // empty string
'"' // character literal
// this is "a string literal" in a comment
/* this is
"also inside"
//a comment */
// and this /*
"is not in a comment"
// */
"this is a /* string */ with nested // comments"
</textarea>
<h2>Output:</h2>
<pre id="output"></pre>