@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/whitebox_kb/wisdom/core/lexer.py

@@ -0,0 +1,512 @@
+"""
+lexer.py · 词法分析器 v2.0（生产版）
+中文分词 + Token 识别
+支持道德经助记符、九章算术结构、中文标点
+
+v2.0 算法（两阶段）：
+阶段一（粗分）：逐字符扫描，按"类型"分组
+  - 中文串（连续 CJK）
+  - 字母串（连续 ASCII 字母/数字/下划线）
+  - 数字串（连续数字，含小数点）
+  - 标点（单个）
+  - 空白（跳过）
+  - 字符串（引号包裹）
+
+阶段二（精分）：对每个中文串/字母串做关键字切分
+  - 使用正向最大匹配
+  - 关键字 → Token
+  - 非关键字 → IDENTIFIER
+"""
+
+from enum import Enum, auto
+from dataclasses import dataclass
+from typing import List, Tuple
+
+
+# =============================================================================
+# Token 类型定义
+# =============================================================================
+
+class TokenType(Enum):
+    """Token 类型枚举"""
+    
+    # === 道德经助记符（指令集） ===
+    DAO = auto()          # 道
+    DE = auto()           # 德
+    ZIRAN = auto()        # 自然
+    WUWEI = auto()        # 无为
+    GU = auto()           # 谷
+    PIN = auto()           # 牝
+    ROU = auto()          # 柔
+    PU = auto()           # 朴
+    ZHI = auto()          # 止
+    ZHIZU = auto()        # 知足
+    
+    # === 九章算术结构关键字 ===
+    WENYUE = auto()       # 问曰
+    DAYUE = auto()        # 答曰
+    SHUYUE = auto()       # 术曰
+    
+    # === 条件/逻辑关键字 ===
+    RUO = auto()          # 若
+    ZE = auto()           # 则
+    FOUZE = auto()        # 否则
+    YU = auto()           # 于
+    WEI = auto()          # 为
+    BUWEI = auto()        # 不为
+    QIE = auto()          # 且
+    HUO = auto()          # 或
+    FEI = auto()          # 非
+    DENGYU = auto()       # 等于
+    DAYU = auto()         # 大于
+    XIAOYU = auto()       # 小于
+    
+    # === 循环关键字（当…执行：白箱循环语法）===
+    DANG = auto()         # 当
+    ZHIXING = auto()      # 执行
+    
+    # === 函数关键字（定义…返回：函数抽象）===
+    DINGYI = auto()       # 定义
+    FANHUI = auto()       # 返回
+    
+    # === 标识符与常量 ===
+    IDENTIFIER = auto()   # 标识符
+    NUMBER = auto()        # 数值常量
+    STRING = auto()        # 字符串常量
+    
+    # === 标点符号 ===
+    COMMA = auto()        # ，
+    PERIOD = auto()       # 。
+    SEMICOLON = auto()    # ；
+    COLON = auto()        # ：
+    LPAREN = auto()       # （
+    RPAREN = auto()       # ）
+    ARROW = auto()        # →
+    QUESTION = auto()     # ？
+    EXCLAM = auto()       # ！
+    EQUALS = auto()      # = 或 ＝（赋值符号）
+    
+    # === 算术运算符（循环体/表达式需要）===
+    OP_ADD = auto()       # +
+    OP_SUB = auto()       # -
+    OP_MUL = auto()       # *
+    OP_DIV = auto()       # /
+
+    # === 特殊 ===
+    COMMENT = auto()      # 注释
+    NEWLINE = auto()      # 换行
+    EOF = auto()          # 文件结束
+    UNKNOWN = auto()      # 未知
+
+
+# =============================================================================
+# Token 数据结构
+# =============================================================================
+
+@dataclass
+class Token:
+    """Token 数据类"""
+    type: TokenType
+    value: str
+    line: int = 1
+    column: int = 1
+    
+    def __repr__(self) -> str:
+        """Token 调试表示：类型·值·位置一行式。"""
+        v = str(self.value)[:30]
+        if len(str(self.value)) > 30:
+            v += "..."
+        return f"Token({self.type.name}, '{v}', L{self.line}:C{self.column})"
+
+
+# =============================================================================
+# 关键字映射表
+# =============================================================================
+
+# 所有关键字集合
+KEYWORDS = {
+    # 道德经
+    "道", "德", "自然", "无为", "谷", "牝", "柔", "朴", "止", "知足",
+    # 九章算术
+    "问曰", "答曰", "术曰",
+    # 条件/逻辑
+    "若", "则", "否则", "于", "为", "不为", "且", "或", "非",
+    "等于", "大于", "小于",
+    # 循环（当…执行：白箱循环语法）
+    "当", "执行",
+    # 函数（定义…返回：函数抽象）
+    "定义", "返回",
+    # 中文算术词（加/减/乘/除 → 运算符）
+    "加", "减", "乘", "除",
+}
+
+# 关键字 → TokenType
+KEYWORD_MAP = {
+    "道": TokenType.DAO,
+    "德": TokenType.DE,
+    "自然": TokenType.ZIRAN,
+    "无为": TokenType.WUWEI,
+    "谷": TokenType.GU,
+    "牝": TokenType.PIN,
+    "柔": TokenType.ROU,
+    "朴": TokenType.PU,
+    "止": TokenType.ZHI,
+    "知足": TokenType.ZHIZU,
+    "问曰": TokenType.WENYUE,
+    "答曰": TokenType.DAYUE,
+    "术曰": TokenType.SHUYUE,
+    "若": TokenType.RUO,
+    "则": TokenType.ZE,
+    "否则": TokenType.FOUZE,
+    "于": TokenType.YU,
+    "为": TokenType.WEI,
+    "不为": TokenType.BUWEI,
+    "且": TokenType.QIE,
+    "或": TokenType.HUO,
+    "非": TokenType.FEI,
+    "等于": TokenType.DENGYU,
+    "大于": TokenType.DAYU,
+    "小于": TokenType.XIAOYU,
+    "当": TokenType.DANG,
+    "执行": TokenType.ZHIXING,
+    "定义": TokenType.DINGYI,
+    "返回": TokenType.FANHUI,
+    "加": TokenType.OP_ADD,
+    "减": TokenType.OP_SUB,
+    "乘": TokenType.OP_MUL,
+    "除": TokenType.OP_DIV,
+}
+
+# 按长度降序排列
+SORTED_KW = sorted(KEYWORDS, key=len, reverse=True)
+
+# 中文标点映射
+PUNCTUATION_MAP = {
+    "，": TokenType.COMMA,    ",": TokenType.COMMA,
+    "。": TokenType.PERIOD,    ".": TokenType.PERIOD,
+    "；": TokenType.SEMICOLON, ";": TokenType.SEMICOLON,
+    "：": TokenType.COLON,    ":": TokenType.COLON,
+    "（": TokenType.LPAREN,    "(": TokenType.LPAREN,
+    "）": TokenType.RPAREN,    ")": TokenType.RPAREN,
+    "→": TokenType.ARROW,
+    "？": TokenType.QUESTION, "?": TokenType.QUESTION,
+    "！": TokenType.EXCLAM, "!": TokenType.EXCLAM,
+    "=": TokenType.EQUALS, "＝": TokenType.EQUALS,
+    "+": TokenType.OP_ADD, "＋": TokenType.OP_ADD,
+    "-": TokenType.OP_SUB, "－": TokenType.OP_SUB,
+    "*": TokenType.OP_MUL, "×": TokenType.OP_MUL,
+    "/": TokenType.OP_DIV, "÷": TokenType.OP_DIV,
+}
+
+
+# =============================================================================
+# 工具函数
+# =============================================================================
+
+def _is_cjk(ch: str) -> bool:
+    """是否为 CJK 统一汉字"""
+    code = ord(ch)
+    return 0x4E00 <= code <= 0x9FFF
+
+def _is_cjk_or_alpha(ch: str) -> bool:
+    """是否为中文、字母、下划线"""
+    return _is_cjk(ch) or ch.isalpha() or ch == "_"
+
+
+# =============================================================================
+# 词法分析器
+# =============================================================================
+
+class Lexer:
+    """
+    词法分析器 v2.0
+    
+    两阶段分词：
+    阶段一：粗分（按字符类型分组）
+    阶段二：精分（对中文/字母串做关键字切分）
+    """
+    
+    def __init__(self, source: str):
+        """Token 构造：类型·字面值·行号列号。"""
+        self.source = source
+        self.pos = 0
+        self.line = 1
+        self.column = 1
+        self.tokens: List[Token] = []
+        self.errors: List[str] = []
+    
+    def tokenize(self) -> Tuple[List[Token], List[str]]:
+        """执行词法分析"""
+        self.tokens = []
+        self.errors = []
+        self.pos = 0
+        self.line = 1
+        self.column = 1
+        
+        while self.pos < len(self.source):
+            ch = self.source[self.pos]
+            
+            # 换行
+            if ch == "\n":
+                self.line += 1
+                self.column = 1
+                self.pos += 1
+                continue
+            
+            # 空白
+            if ch in (" ", "\t", "\r"):
+                self.column += 1
+                self.pos += 1
+                continue
+            
+            # 注释 //
+            if ch == "/" and self.pos + 1 < len(self.source) and self.source[self.pos + 1] == "/":
+                self._skip_comment()
+                continue
+            
+            # 字符串
+            if ch == '"' or ch == "\u201c":
+                self._read_string()
+                continue
+            
+            # 数字（包括 . 开头的小数）
+            if ch.isdigit() or ch == "." or (ch == "-" and self._peek_isdigit()):
+                self._read_number()
+                continue
+            
+            # 中文标点
+            if ch in PUNCTUATION_MAP:
+                self._emit(PUNCTUATION_MAP[ch], ch)
+                self.pos += 1
+                self.column += 1
+                continue
+
+            # 赋值符号 = （ASCII）或 ＝（全角）
+            if ch == "=" or ch == "\uFF1D":
+                self._emit(TokenType.EQUALS, ch)
+                self.pos += 1
+                self.column += 1
+                continue
+            
+            # 中文/字母/下划线 → 粗分 + 精分
+            if _is_cjk_or_alpha(ch):
+                self._read_and_segment()
+                continue
+            
+            # 未知字符
+            self.errors.append(f"L{self.line}:C{self.column} 未知字符: '{ch}' (U+{ord(ch):04X})")
+            self.pos += 1
+            self.column += 1
+        
+        self._emit(TokenType.EOF, "")
+        return self.tokens, self.errors
+    
+    # ---- 阶段一：粗分 ----
+    
+    def _read_and_segment(self):
+        """
+        读取连续的中文/字母/数字/下划线，然后做关键字精分
+        
+        这是核心方法：
+        1. 贪婪读取所有"词字符"（中文/字母/数字/下划线）
+        2. 对结果做正向最大匹配切分
+        """
+        start_col = self.column
+        start_pos = self.pos
+        
+        # 贪婪读取
+        while self.pos < len(self.source):
+            ch = self.source[self.pos]
+            if _is_cjk_or_alpha(ch) or ch.isdigit():
+                self.pos += 1
+            else:
+                break
+        
+        text = self.source[start_pos:self.pos]
+        self.column += (self.pos - start_pos)
+        
+        # 阶段二：精分
+        self._segment(text, start_col)
+    
+    # ---- 阶段二：精分 ----
+    
+    def _segment(self, text: str, start_col: int):
+        """
+        正向最大匹配（Forward Maximum Matching）
+        
+        对 text 中的每个位置，找最长的匹配关键字。
+        如果找不到关键字，发出单个字符作为 IDENTIFIER。
+        
+        关键改进：使用位置指针 i 遍历 text，
+        每次从 i 开始找最长关键字。
+        找到后 i 跳过该关键字长度。
+        找不到时 i 前进 1（发出单个字符）。
+        
+        标识符规则：连续 CJK 串优先整体为标识符（如「阶乘」含关键词「乘」，
+        但整体不是关键词 → 保持为标识符，避免误切分）。
+        """
+        i = 0
+        col = start_col
+        
+        while i < len(text):
+            # 尝试从位置 i 找最长关键字
+            matched_kw = None
+            matched_len = 0
+            
+            for kw in SORTED_KW:
+                if text.startswith(kw, i):
+                    if len(kw) > matched_len:
+                        matched_kw = kw
+                        matched_len = len(kw)
+            
+            if matched_kw is not None:
+                # 发出关键字 token
+                self._emit(KEYWORD_MAP[matched_kw], matched_kw, col)
+                i += matched_len
+                col += matched_len
+            else:
+                # 不是关键字 → 收集连续的非关键字字符作为标识符
+                # 中文规则：连续 CJK 串优先整体为标识符（如「阶乘」含关键词「乘」，
+                # 但整串「阶乘」非关键词 → 保持整体，避免误切分）
+                ident_start = i
+                ident_col = col
+                
+                if _is_cjk(text[i]):
+                    while i < len(text) and _is_cjk(text[i]):
+                        i += 1
+                        col += 1
+                else:
+                    while i < len(text):
+                        ch = text[i]
+                        has_kw_ahead = any(text.startswith(kw, i) for kw in SORTED_KW)
+                        if has_kw_ahead:
+                            break
+                        i += 1
+                        col += 1
+                
+                ident = text[ident_start:i]
+                if ident:
+                    self._emit(TokenType.IDENTIFIER, ident, ident_col)
+    
+    # ---- 数字读取 ----
+    
+    def _peek_isdigit(self) -> bool:
+        """前瞻当前字符是否数字（多位数聚合判断）。"""
+        return self.pos + 1 < len(self.source) and self.source[self.pos + 1].isdigit()
+    
+    def _read_number(self):
+        """读取数值（支持整数、小数、负数）"""
+        start_col = self.column
+        result = []
+        
+        # 负号
+        if self.source[self.pos] == "-":
+            result.append("-")
+            self.pos += 1
+            self.column += 1
+        
+        # 整数部分
+        while self.pos < len(self.source) and self.source[self.pos].isdigit():
+            result.append(self.source[self.pos])
+            self.pos += 1
+            self.column += 1
+        
+        # 小数部分
+        if self.pos < len(self.source) and self.source[self.pos] == ".":
+            result.append(".")
+            self.pos += 1
+            self.column += 1
+            while self.pos < len(self.source) and self.source[self.pos].isdigit():
+                result.append(self.source[self.pos])
+                self.pos += 1
+                self.column += 1
+        
+        num_str = "".join(result)
+        try:
+            float(num_str)
+            self._emit(TokenType.NUMBER, num_str)
+        except ValueError:
+            self.errors.append(f"L{self.line}:C{start_col} 非法数值: '{num_str}'")
+            self._emit(TokenType.NUMBER, num_str)
+    
+    # ---- 字符串读取 ----
+    
+    def _read_string(self):
+        """读取字符串"""
+        quote_char = self.source[self.pos]
+        end_quote = '"' if quote_char == '"' else "\u201d"
+        
+        self.pos += 1
+        self.column += 1
+        result = []
+        
+        while self.pos < len(self.source) and self.source[self.pos] != end_quote:
+            ch = self.source[self.pos]
+            if ch == "\n":
+                self.errors.append(f"L{self.line}:C{self.column} 字符串未闭合")
+                break
+            result.append(ch)
+            self.pos += 1
+            self.column += 1
+        
+        if self.pos < len(self.source):
+            self.pos += 1  # 跳过结束引号
+            self.column += 1
+        
+        self._emit(TokenType.STRING, "".join(result))
+    
+    # ---- 注释跳过 ----
+    
+    def _skip_comment(self):
+        """跳过注释至本行结束。"""
+        while self.pos < len(self.source) and self.source[self.pos] != "\n":
+            self.pos += 1
+    
+    # ---- Token 输出 ----
+    
+    def _emit(self, token_type: TokenType, value: str, col: int = None):
+        """输出一个 Token"""
+        c = col if col is not None else self.column
+        self.tokens.append(Token(token_type, value, self.line, c))
+
+
+# =============================================================================
+# 便捷函数
+# =============================================================================
+
+def tokenize(source: str) -> Tuple[List[Token], List[str]]:
+    """便捷函数"""
+    lexer = Lexer(source)
+    return lexer.tokenize()
+
+
+# =============================================================================
+# 测试
+# =============================================================================
+
+if __name__ == "__main__":
+    test_code = """若条件空间为伴侣，则止情感权重于0.15。
+道 新信任路径
+问曰：如何验证信任？
+答曰：信任值大于0.7。
+术曰：1。德 累积信任值；2。自然 恢复默认。"""
+    
+    print("=" * 60)
+    print("词法分析器 v2.0 测试")
+    print("=" * 60)
+    print(f"源代码：\n{test_code}\n")
+    
+    tokens, errors = tokenize(test_code)
+    
+    print("Token 序列：")
+    for t in tokens:
+        if t.type != TokenType.EOF:
+            print(f"  {t}")
+    
+    if errors:
+        print(f"\n错误：")
+        for e in errors:
+            print(f"  ❌ {e}")
+    
+    valid = len([t for t in tokens if t.type != TokenType.EOF])
+    print(f"\n总计：{valid} 个 Token，{len(errors)} 个错误")