CN·语言

正则

递归回溯式正则引擎——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)

递归下降匹配器内部方法:顶层或分派/原子序列推进/贪婪回退/单原子匹配/字符类判定。读源码对照用,勿外部调用。