正则
递归回溯式正则引擎——Rob Pike TregEx 风格的实用子集。
导入写法CN
导入 正则::正则引擎;支持的语法子集
| 语法 | 含义 |
|---|---|
字面量 | 逐字符匹配(UTF-8 字节级) |
. | 任意单字节(不含 \0) |
[abc] [a-z0-9] [^a] | 字符类:枚举/区间/取反 |
^ $ | 行首/行尾锚定 |
* + ? | 量词(仅作用于单字符原子:字面量/. /字符类/转义;贪婪+回退) |
( … ) | 分组(组内可用 |;组不可接量词) |
| | 或(顶层与组内) |
\x | 转义 \ . [ ] ( ) * + ? | ^ $ |
语法子集.cnCN
导入 正则::正则引擎;
函数 主() -> 整32 {
正则引擎 re = 正则引擎("^h[oai]+t$");
打印(re.完全匹配("hoat")); // 真(^ $ 锚定整串)
打印(re.完全匹配("hot!")); // 假
正则引擎 查找 = 正则引擎("h[oai]+t"); // 无锚:可命中任意起点
可选<整64> 起点 = 查找.搜索("shot boy");
如果 (起点.有值) {
打印(起点.值); // 1
}
返回 0;
}输出:真 假 1
正则引擎(模式串)
函数 正则引擎(字符串 模式串)
以模式串构造引擎。模式在每次 搜索/完全匹配 时解释执行(无独立编译步骤)。
| 参数 | 类型 | 说明 |
|---|---|---|
模式串 | 字符串 | 正则模式(语法见上表) |
主.cnCN
公开:
类 正则引擎 {
字符串 模式文;
字符串 目标文;
整64 目标长;
公开:
函数 正则引擎(字符串 模式串) {
模式文 = 模式串;
目标长 = 0;
}
// 搜索:返回文本中首个匹配的起点;-1 = 无匹配
函数 搜索(字符串 输入) -> 整64 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 行首锚 = 假;
如果 (模长 > 0) {
行首锚 = 模式文[0] == '^';
}
如果 (行首锚) {
模式起点 = 1;
}
整64 起点 = 0;
当 (起点 <= 目标长) {
如果 (行首锚 && 起点 != 0) {
返回 -1;
}
整64 终 = 自身.匹配或(模式起点, 模长, 起点);
如果 (终 >= 0) {
返回 起点;
}
起点 = 起点 + 1;
}
返回 -1;
}
// 完全匹配:整个文本须被模式完整覆盖
函数 完全匹配(字符串 输入) -> 布尔 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 有首锚 = 假;
如果 (模长 > 0) {
有首锚 = 模式文[0] == '^';
}
如果 (有首锚) {
模式起点 = 1;
}
整64 模式止 = 模长;
布尔 有尾锚 = 假;
如果 (模式止 > 模式起点) {
有尾锚 = 模式文[模式止 - 1] == '$';
}
如果 (有尾锚) {
模式止 = 模式止 - 1;
}
整64 终 = 自身.匹配或(模式起点, 模式止, 0);
返回 终 == 目标长;
}
// ===== 匹配或:扫描 [起,止) 内顶层 '|',先左后右 =====
函数 匹配或(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 深度 = 0;
整64 i = 起;
当 (i < 止) {
字符 c = 模式文[i];
如果 (c == '\\') {
i = i + 2;
继续;
}
如果 (c == '[') {
i = i + 1;
当 (i < 止 && 模式文[i] != ']') {
如果 (模式文[i] == '\\') {
i = i + 1;
}
i = i + 1;
}
i = i + 1;
继续;
}
如果 (c == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (c == ')') {
深度 = 深度 - 1;
} 否则 {
如果 (c == '|' && 深度 == 0) {
整64 左 = 自身.匹配序列(起, i, 位置);
如果 (左 >= 0) {
返回 左;
}
返回 自身.匹配或(i + 1, 止, 位置);
}
}
}
i = i + 1;
}
返回 自身.匹配序列(起, 止, 位置);
}
// ===== 匹配序列:逐原子推进(含量词处理与尾锚 $) =====
函数 匹配序列(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 i = 起;
整64 位置p = 位置;
当 (i < 止) {
字符 c = 模式文[i];
// 尾锚 $(模式末位零宽断言)
如果 (c == '$' && i + 1 == 止) {
如果 (位置p == 目标长) {
返回 位置p;
}
返回 -1;
}
// 原子解析:[原子起, 原子止)
整64 原子起 = i;
整64 原子止 = i;
如果 (c == '\\') {
原子止 = i + 2;
} 否则 {
如果 (c == '[') {
整64 j = i + 1;
当 (j < 止 && 模式文[j] != ']') {
如果 (模式文[j] == '\\') {
j = j + 1;
}
j = j + 1;
}
原子止 = j + 1;
} 否则 {
如果 (c == '(') {
整64 深度 = 1;
整64 j = i + 1;
当 (j < 止 && 深度 > 0) {
如果 (模式文[j] == '\\') {
j = j + 1;
} 否则 {
如果 (模式文[j] == '[') {
j = j + 1;
当 (j < 止 && 模式文[j] != ']') {
j = j + 1;
}
} 否则 {
如果 (模式文[j] == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (模式文[j] == ')') {
深度 = 深度 - 1;
}
}
}
}
j = j + 1;
}
原子止 = j;
} 否则 {
原子止 = i + 1;
}
}
}
整64 余起 = 原子止;
字符 量词 = ' ';
如果 (原子止 < 止) {
字符 下 = 模式文[原子止];
如果 (下 == '*' || 下 == '+' || 下 == '?') {
量词 = 下;
余起 = 原子止 + 1;
}
}
// 量词分派:量词分支「返回型」——余下模式已由递归(贪婪/可选)消费并
// 返回终点,外层不得再循环消费余下原子(否则双重消费恒失败)
如果 (量词 == ' ') {
位置p = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (位置p < 0) {
返回 -1;
}
i = 余起;
} 否则 {
如果 (量词 == '?') {
整64 一位 = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (一位 >= 0) {
整64 rr = 自身.匹配序列(余起, 止, 一位);
如果 (rr >= 0) {
返回 rr;
}
}
返回 自身.匹配序列(余起, 止, 位置p);
} 否则 {
整64 最少 = 0;
如果 (量词 == '+') {
最少 = 1;
}
返回 自身.贪婪循环(原子起, 原子止, 余起, 止, 位置p, 0, 最少);
}
}
}
返回 位置p;
}
// ===== 贪婪循环:* 与 + 的多吃后回退(防零宽空转死循环) =====
函数 贪婪循环(整64 原子起, 整64 原子止, 整64 余起, 整64 止,
整64 位置, 整64 次数, 整64 最少) -> 整64 {
整64 下一位 = 自身.匹配原子(原子起, 原子止, 位置);
如果 (下一位 > 位置) {
整64 r = 自身.贪婪循环(原子起, 原子止, 余起, 止, 下一位, 次数 + 1, 最少);
如果 (r >= 0) {
返回 r;
}
}
如果 (次数 >= 最少) {
返回 自身.匹配序列(余起, 止, 位置);
}
返回 -1;
}
// ===== 匹配原子:单次匹配 [起,止),返回新文本位或 -1 =====
函数 匹配原子(整64 起, 整64 止, 整64 位置) -> 整64 {
如果 (位置 >= 目标长) {
返回 -1;
}
字符 c = 模式文[起];
// 转义序列:\x 按字面量字符 x 匹配
如果 (c == '\\' && 止 == 起 + 2) {
如果 (目标文[位置] == 模式文[起 + 1]) {
返回 位置 + 1;
}
返回 -1;
}
// 字符类 [ … ]
如果 (c == '[') {
整64 类起 = 起 + 1;
整64 类止 = 止 - 1;
布尔 取反 = 假;
如果 (类起 < 类止 && 模式文[类起] == '^') {
取反 = 真;
类起 = 类起 + 1;
}
布尔 命中 = 自身.类含(类起, 类止, 目标文[位置]);
如果 (取反) {
命中 = !命中;
}
如果 (命中) {
返回 位置 + 1;
}
返回 -1;
}
// 分组 ( … ):组内或匹配(首个成功分支·不回溯——语义边界见文件头)
如果 (c == '(') {
整64 内起 = 起 + 1;
整64 内止 = 止 - 1;
整64 r = 自身.匹配或(内起, 内止, 位置);
如果 (r >= 0 && r <= 目标长) {
返回 r;
}
返回 -1;
}
// 点号:任意单字节(不含 \0)
如果 (c == '.') {
如果 (目标文[位置] != '\0') {
返回 位置 + 1;
}
返回 -1;
}
// 普通字面量字符
如果 (目标文[位置] == c) {
返回 位置 + 1;
}
返回 -1;
}
// ===== 类含:字符类 [类起,类止) 是否含指定字符(区间 a-z 与转义) =====
函数 类含(整64 类起, 整64 类止, 字符 目标) -> 布尔 {
整64 i = 类起;
当 (i < 类止) {
字符 低 = 模式文[i];
如果 (低 == '\\' && i + 1 < 类止) {
如果 (模式文[i + 1] == 目标) {
返回 真;
}
i = i + 2;
继续;
}
// 区间 a-z('-' 非首位/末位时)
如果 (i + 2 < 类止 && 模式文[i + 1] == '-' && 模式文[i + 2] != '\\') {
如果 (目标 >= 低 && 目标 <= 模式文[i + 2]) {
返回 真;
}
i = i + 3;
继续;
}
如果 (目标 == 低) {
返回 真;
}
i = i + 1;
}
返回 假;
}
}
函数 主() -> 整32 {
整64 累 = 0;
// 位1:字面量完全匹配
正则引擎 甲 = 正则引擎("ab");
如果 (甲.完全匹配("ab") && !甲.完全匹配("a")) {
累 = 累 + 1;
}
// 位2:字符类 + 量词 + 搜索
正则引擎 乙 = 正则引擎("[abc]+");
如果 (乙.搜索("zzcabz") == 2) {
累 = 累 + 2;
}
// 位4:锚定 ^ $
正则引擎 丙 = 正则引擎("^h[oai]+t$");
如果 (丙.完全匹配("hoat") && !丙.完全匹配("hell")) {
累 = 累 + 4;
}
// 位8:量词序列(* 与 ?)
正则引擎 丁 = 正则引擎("a*b?c");
如果 (丁.完全匹配("aaac") && 丁.完全匹配("c") && !丁.完全匹配("b")) {
累 = 累 + 8;
}
// 位16:分组与或
正则引擎 戊 = 正则引擎("(a|b)+d");
如果 (戊.搜索("xxbad") == 2) {
累 = 累 + 16;
}
返回 整32(累);
}输出:[p6h] 已解析: target/audit2/v2src363/主.cn
搜索
函数 搜索(字符串 输入) -> 可选<整64>
在文本中寻找首个匹配,命中返回匹配起点下标(某些);无匹配=无(#1360 结果化,-1 哨兵废除)。模式以 ^ 开头时只尝试起点 0。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 被搜索的文本 |
返回 命中=某些(起点);无匹配=无。
主.cnCN
公开:
类 正则引擎 {
字符串 模式文;
字符串 目标文;
整64 目标长;
公开:
函数 正则引擎(字符串 模式串) {
模式文 = 模式串;
目标长 = 0;
}
// 搜索:返回文本中首个匹配的起点;-1 = 无匹配
函数 搜索(字符串 输入) -> 整64 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 行首锚 = 假;
如果 (模长 > 0) {
行首锚 = 模式文[0] == '^';
}
如果 (行首锚) {
模式起点 = 1;
}
整64 起点 = 0;
当 (起点 <= 目标长) {
如果 (行首锚 && 起点 != 0) {
返回 -1;
}
整64 终 = 自身.匹配或(模式起点, 模长, 起点);
如果 (终 >= 0) {
返回 起点;
}
起点 = 起点 + 1;
}
返回 -1;
}
// 完全匹配:整个文本须被模式完整覆盖
函数 完全匹配(字符串 输入) -> 布尔 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 有首锚 = 假;
如果 (模长 > 0) {
有首锚 = 模式文[0] == '^';
}
如果 (有首锚) {
模式起点 = 1;
}
整64 模式止 = 模长;
布尔 有尾锚 = 假;
如果 (模式止 > 模式起点) {
有尾锚 = 模式文[模式止 - 1] == '$';
}
如果 (有尾锚) {
模式止 = 模式止 - 1;
}
整64 终 = 自身.匹配或(模式起点, 模式止, 0);
返回 终 == 目标长;
}
// ===== 匹配或:扫描 [起,止) 内顶层 '|',先左后右 =====
函数 匹配或(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 深度 = 0;
整64 i = 起;
当 (i < 止) {
字符 c = 模式文[i];
如果 (c == '\\') {
i = i + 2;
继续;
}
如果 (c == '[') {
i = i + 1;
当 (i < 止 && 模式文[i] != ']') {
如果 (模式文[i] == '\\') {
i = i + 1;
}
i = i + 1;
}
i = i + 1;
继续;
}
如果 (c == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (c == ')') {
深度 = 深度 - 1;
} 否则 {
如果 (c == '|' && 深度 == 0) {
整64 左 = 自身.匹配序列(起, i, 位置);
如果 (左 >= 0) {
返回 左;
}
返回 自身.匹配或(i + 1, 止, 位置);
}
}
}
i = i + 1;
}
返回 自身.匹配序列(起, 止, 位置);
}
// ===== 匹配序列:逐原子推进(含量词处理与尾锚 $) =====
函数 匹配序列(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 i = 起;
整64 位置p = 位置;
当 (i < 止) {
字符 c = 模式文[i];
// 尾锚 $(模式末位零宽断言)
如果 (c == '$' && i + 1 == 止) {
如果 (位置p == 目标长) {
返回 位置p;
}
返回 -1;
}
// 原子解析:[原子起, 原子止)
整64 原子起 = i;
整64 原子止 = i;
如果 (c == '\\') {
原子止 = i + 2;
} 否则 {
如果 (c == '[') {
整64 j = i + 1;
当 (j < 止 && 模式文[j] != ']') {
如果 (模式文[j] == '\\') {
j = j + 1;
}
j = j + 1;
}
原子止 = j + 1;
} 否则 {
如果 (c == '(') {
整64 深度 = 1;
整64 j = i + 1;
当 (j < 止 && 深度 > 0) {
如果 (模式文[j] == '\\') {
j = j + 1;
} 否则 {
如果 (模式文[j] == '[') {
j = j + 1;
当 (j < 止 && 模式文[j] != ']') {
j = j + 1;
}
} 否则 {
如果 (模式文[j] == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (模式文[j] == ')') {
深度 = 深度 - 1;
}
}
}
}
j = j + 1;
}
原子止 = j;
} 否则 {
原子止 = i + 1;
}
}
}
整64 余起 = 原子止;
字符 量词 = ' ';
如果 (原子止 < 止) {
字符 下 = 模式文[原子止];
如果 (下 == '*' || 下 == '+' || 下 == '?') {
量词 = 下;
余起 = 原子止 + 1;
}
}
// 量词分派:量词分支「返回型」——余下模式已由递归(贪婪/可选)消费并
// 返回终点,外层不得再循环消费余下原子(否则双重消费恒失败)
如果 (量词 == ' ') {
位置p = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (位置p < 0) {
返回 -1;
}
i = 余起;
} 否则 {
如果 (量词 == '?') {
整64 一位 = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (一位 >= 0) {
整64 rr = 自身.匹配序列(余起, 止, 一位);
如果 (rr >= 0) {
返回 rr;
}
}
返回 自身.匹配序列(余起, 止, 位置p);
} 否则 {
整64 最少 = 0;
如果 (量词 == '+') {
最少 = 1;
}
返回 自身.贪婪循环(原子起, 原子止, 余起, 止, 位置p, 0, 最少);
}
}
}
返回 位置p;
}
// ===== 贪婪循环:* 与 + 的多吃后回退(防零宽空转死循环) =====
函数 贪婪循环(整64 原子起, 整64 原子止, 整64 余起, 整64 止,
整64 位置, 整64 次数, 整64 最少) -> 整64 {
整64 下一位 = 自身.匹配原子(原子起, 原子止, 位置);
如果 (下一位 > 位置) {
整64 r = 自身.贪婪循环(原子起, 原子止, 余起, 止, 下一位, 次数 + 1, 最少);
如果 (r >= 0) {
返回 r;
}
}
如果 (次数 >= 最少) {
返回 自身.匹配序列(余起, 止, 位置);
}
返回 -1;
}
// ===== 匹配原子:单次匹配 [起,止),返回新文本位或 -1 =====
函数 匹配原子(整64 起, 整64 止, 整64 位置) -> 整64 {
如果 (位置 >= 目标长) {
返回 -1;
}
字符 c = 模式文[起];
// 转义序列:\x 按字面量字符 x 匹配
如果 (c == '\\' && 止 == 起 + 2) {
如果 (目标文[位置] == 模式文[起 + 1]) {
返回 位置 + 1;
}
返回 -1;
}
// 字符类 [ … ]
如果 (c == '[') {
整64 类起 = 起 + 1;
整64 类止 = 止 - 1;
布尔 取反 = 假;
如果 (类起 < 类止 && 模式文[类起] == '^') {
取反 = 真;
类起 = 类起 + 1;
}
布尔 命中 = 自身.类含(类起, 类止, 目标文[位置]);
如果 (取反) {
命中 = !命中;
}
如果 (命中) {
返回 位置 + 1;
}
返回 -1;
}
// 分组 ( … ):组内或匹配(首个成功分支·不回溯——语义边界见文件头)
如果 (c == '(') {
整64 内起 = 起 + 1;
整64 内止 = 止 - 1;
整64 r = 自身.匹配或(内起, 内止, 位置);
如果 (r >= 0 && r <= 目标长) {
返回 r;
}
返回 -1;
}
// 点号:任意单字节(不含 \0)
如果 (c == '.') {
如果 (目标文[位置] != '\0') {
返回 位置 + 1;
}
返回 -1;
}
// 普通字面量字符
如果 (目标文[位置] == c) {
返回 位置 + 1;
}
返回 -1;
}
// ===== 类含:字符类 [类起,类止) 是否含指定字符(区间 a-z 与转义) =====
函数 类含(整64 类起, 整64 类止, 字符 目标) -> 布尔 {
整64 i = 类起;
当 (i < 类止) {
字符 低 = 模式文[i];
如果 (低 == '\\' && i + 1 < 类止) {
如果 (模式文[i + 1] == 目标) {
返回 真;
}
i = i + 2;
继续;
}
// 区间 a-z('-' 非首位/末位时)
如果 (i + 2 < 类止 && 模式文[i + 1] == '-' && 模式文[i + 2] != '\\') {
如果 (目标 >= 低 && 目标 <= 模式文[i + 2]) {
返回 真;
}
i = i + 3;
继续;
}
如果 (目标 == 低) {
返回 真;
}
i = i + 1;
}
返回 假;
}
}
函数 主() -> 整32 {
整64 累 = 0;
// 位1:字面量完全匹配
正则引擎 甲 = 正则引擎("ab");
如果 (甲.完全匹配("ab") && !甲.完全匹配("a")) {
累 = 累 + 1;
}
// 位2:字符类 + 量词 + 搜索
正则引擎 乙 = 正则引擎("[abc]+");
如果 (乙.搜索("zzcabz") == 2) {
累 = 累 + 2;
}
// 位4:锚定 ^ $
正则引擎 丙 = 正则引擎("^h[oai]+t$");
如果 (丙.完全匹配("hoat") && !丙.完全匹配("hell")) {
累 = 累 + 4;
}
// 位8:量词序列(* 与 ?)
正则引擎 丁 = 正则引擎("a*b?c");
如果 (丁.完全匹配("aaac") && 丁.完全匹配("c") && !丁.完全匹配("b")) {
累 = 累 + 8;
}
// 位16:分组与或
正则引擎 戊 = 正则引擎("(a|b)+d");
如果 (戊.搜索("xxbad") == 2) {
累 = 累 + 16;
}
返回 整32(累);
}输出:[p6h] 已解析: target/audit2/v2src363/主.cn
完全匹配
函数 完全匹配(字符串 输入) -> 布尔
整个文本须被模式完整覆盖(首尾隐式锚定,无需写 ^ $)。
| 参数 | 类型 | 说明 |
|---|---|---|
输入 | 字符串 | 被检验的文本 |
返回 完整覆盖为真,否则假。
主.cnCN
公开:
类 正则引擎 {
字符串 模式文;
字符串 目标文;
整64 目标长;
公开:
函数 正则引擎(字符串 模式串) {
模式文 = 模式串;
目标长 = 0;
}
// 搜索:返回文本中首个匹配的起点;-1 = 无匹配
函数 搜索(字符串 输入) -> 整64 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 行首锚 = 假;
如果 (模长 > 0) {
行首锚 = 模式文[0] == '^';
}
如果 (行首锚) {
模式起点 = 1;
}
整64 起点 = 0;
当 (起点 <= 目标长) {
如果 (行首锚 && 起点 != 0) {
返回 -1;
}
整64 终 = 自身.匹配或(模式起点, 模长, 起点);
如果 (终 >= 0) {
返回 起点;
}
起点 = 起点 + 1;
}
返回 -1;
}
// 完全匹配:整个文本须被模式完整覆盖
函数 完全匹配(字符串 输入) -> 布尔 {
目标文 = 输入;
目标长 = 字符串长度(输入);
整64 模长 = 字符串长度(模式文);
整64 模式起点 = 0;
布尔 有首锚 = 假;
如果 (模长 > 0) {
有首锚 = 模式文[0] == '^';
}
如果 (有首锚) {
模式起点 = 1;
}
整64 模式止 = 模长;
布尔 有尾锚 = 假;
如果 (模式止 > 模式起点) {
有尾锚 = 模式文[模式止 - 1] == '$';
}
如果 (有尾锚) {
模式止 = 模式止 - 1;
}
整64 终 = 自身.匹配或(模式起点, 模式止, 0);
返回 终 == 目标长;
}
// ===== 匹配或:扫描 [起,止) 内顶层 '|',先左后右 =====
函数 匹配或(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 深度 = 0;
整64 i = 起;
当 (i < 止) {
字符 c = 模式文[i];
如果 (c == '\\') {
i = i + 2;
继续;
}
如果 (c == '[') {
i = i + 1;
当 (i < 止 && 模式文[i] != ']') {
如果 (模式文[i] == '\\') {
i = i + 1;
}
i = i + 1;
}
i = i + 1;
继续;
}
如果 (c == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (c == ')') {
深度 = 深度 - 1;
} 否则 {
如果 (c == '|' && 深度 == 0) {
整64 左 = 自身.匹配序列(起, i, 位置);
如果 (左 >= 0) {
返回 左;
}
返回 自身.匹配或(i + 1, 止, 位置);
}
}
}
i = i + 1;
}
返回 自身.匹配序列(起, 止, 位置);
}
// ===== 匹配序列:逐原子推进(含量词处理与尾锚 $) =====
函数 匹配序列(整64 起, 整64 止, 整64 位置) -> 整64 {
整64 i = 起;
整64 位置p = 位置;
当 (i < 止) {
字符 c = 模式文[i];
// 尾锚 $(模式末位零宽断言)
如果 (c == '$' && i + 1 == 止) {
如果 (位置p == 目标长) {
返回 位置p;
}
返回 -1;
}
// 原子解析:[原子起, 原子止)
整64 原子起 = i;
整64 原子止 = i;
如果 (c == '\\') {
原子止 = i + 2;
} 否则 {
如果 (c == '[') {
整64 j = i + 1;
当 (j < 止 && 模式文[j] != ']') {
如果 (模式文[j] == '\\') {
j = j + 1;
}
j = j + 1;
}
原子止 = j + 1;
} 否则 {
如果 (c == '(') {
整64 深度 = 1;
整64 j = i + 1;
当 (j < 止 && 深度 > 0) {
如果 (模式文[j] == '\\') {
j = j + 1;
} 否则 {
如果 (模式文[j] == '[') {
j = j + 1;
当 (j < 止 && 模式文[j] != ']') {
j = j + 1;
}
} 否则 {
如果 (模式文[j] == '(') {
深度 = 深度 + 1;
} 否则 {
如果 (模式文[j] == ')') {
深度 = 深度 - 1;
}
}
}
}
j = j + 1;
}
原子止 = j;
} 否则 {
原子止 = i + 1;
}
}
}
整64 余起 = 原子止;
字符 量词 = ' ';
如果 (原子止 < 止) {
字符 下 = 模式文[原子止];
如果 (下 == '*' || 下 == '+' || 下 == '?') {
量词 = 下;
余起 = 原子止 + 1;
}
}
// 量词分派:量词分支「返回型」——余下模式已由递归(贪婪/可选)消费并
// 返回终点,外层不得再循环消费余下原子(否则双重消费恒失败)
如果 (量词 == ' ') {
位置p = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (位置p < 0) {
返回 -1;
}
i = 余起;
} 否则 {
如果 (量词 == '?') {
整64 一位 = 自身.匹配原子(原子起, 原子止, 位置p);
如果 (一位 >= 0) {
整64 rr = 自身.匹配序列(余起, 止, 一位);
如果 (rr >= 0) {
返回 rr;
}
}
返回 自身.匹配序列(余起, 止, 位置p);
} 否则 {
整64 最少 = 0;
如果 (量词 == '+') {
最少 = 1;
}
返回 自身.贪婪循环(原子起, 原子止, 余起, 止, 位置p, 0, 最少);
}
}
}
返回 位置p;
}
// ===== 贪婪循环:* 与 + 的多吃后回退(防零宽空转死循环) =====
函数 贪婪循环(整64 原子起, 整64 原子止, 整64 余起, 整64 止,
整64 位置, 整64 次数, 整64 最少) -> 整64 {
整64 下一位 = 自身.匹配原子(原子起, 原子止, 位置);
如果 (下一位 > 位置) {
整64 r = 自身.贪婪循环(原子起, 原子止, 余起, 止, 下一位, 次数 + 1, 最少);
如果 (r >= 0) {
返回 r;
}
}
如果 (次数 >= 最少) {
返回 自身.匹配序列(余起, 止, 位置);
}
返回 -1;
}
// ===== 匹配原子:单次匹配 [起,止),返回新文本位或 -1 =====
函数 匹配原子(整64 起, 整64 止, 整64 位置) -> 整64 {
如果 (位置 >= 目标长) {
返回 -1;
}
字符 c = 模式文[起];
// 转义序列:\x 按字面量字符 x 匹配
如果 (c == '\\' && 止 == 起 + 2) {
如果 (目标文[位置] == 模式文[起 + 1]) {
返回 位置 + 1;
}
返回 -1;
}
// 字符类 [ … ]
如果 (c == '[') {
整64 类起 = 起 + 1;
整64 类止 = 止 - 1;
布尔 取反 = 假;
如果 (类起 < 类止 && 模式文[类起] == '^') {
取反 = 真;
类起 = 类起 + 1;
}
布尔 命中 = 自身.类含(类起, 类止, 目标文[位置]);
如果 (取反) {
命中 = !命中;
}
如果 (命中) {
返回 位置 + 1;
}
返回 -1;
}
// 分组 ( … ):组内或匹配(首个成功分支·不回溯——语义边界见文件头)
如果 (c == '(') {
整64 内起 = 起 + 1;
整64 内止 = 止 - 1;
整64 r = 自身.匹配或(内起, 内止, 位置);
如果 (r >= 0 && r <= 目标长) {
返回 r;
}
返回 -1;
}
// 点号:任意单字节(不含 \0)
如果 (c == '.') {
如果 (目标文[位置] != '\0') {
返回 位置 + 1;
}
返回 -1;
}
// 普通字面量字符
如果 (目标文[位置] == c) {
返回 位置 + 1;
}
返回 -1;
}
// ===== 类含:字符类 [类起,类止) 是否含指定字符(区间 a-z 与转义) =====
函数 类含(整64 类起, 整64 类止, 字符 目标) -> 布尔 {
整64 i = 类起;
当 (i < 类止) {
字符 低 = 模式文[i];
如果 (低 == '\\' && i + 1 < 类止) {
如果 (模式文[i + 1] == 目标) {
返回 真;
}
i = i + 2;
继续;
}
// 区间 a-z('-' 非首位/末位时)
如果 (i + 2 < 类止 && 模式文[i + 1] == '-' && 模式文[i + 2] != '\\') {
如果 (目标 >= 低 && 目标 <= 模式文[i + 2]) {
返回 真;
}
i = i + 3;
继续;
}
如果 (目标 == 低) {
返回 真;
}
i = i + 1;
}
返回 假;
}
}
函数 主() -> 整32 {
整64 累 = 0;
// 位1:字面量完全匹配
正则引擎 甲 = 正则引擎("ab");
如果 (甲.完全匹配("ab") && !甲.完全匹配("a")) {
累 = 累 + 1;
}
// 位2:字符类 + 量词 + 搜索
正则引擎 乙 = 正则引擎("[abc]+");
如果 (乙.搜索("zzcabz") == 2) {
累 = 累 + 2;
}
// 位4:锚定 ^ $
正则引擎 丙 = 正则引擎("^h[oai]+t$");
如果 (丙.完全匹配("hoat") && !丙.完全匹配("hell")) {
累 = 累 + 4;
}
// 位8:量词序列(* 与 ?)
正则引擎 丁 = 正则引擎("a*b?c");
如果 (丁.完全匹配("aaac") && 丁.完全匹配("c") && !丁.完全匹配("b")) {
累 = 累 + 8;
}
// 位16:分组与或
正则引擎 戊 = 正则引擎("(a|b)+d");
如果 (戊.搜索("xxbad") == 2) {
累 = 累 + 16;
}
返回 整32(累);
}输出:[p6h] 已解析: target/audit2/v2src363/主.cn
匹配或 / 匹配序列 / 贪婪循环 / 匹配原子 / 类含 内部
(内部方法 × 5)
递归下降匹配器内部方法:顶层或分派/原子序列推进/贪婪回退/单原子匹配/字符类判定。读源码对照用,勿外部调用。