cfgrammar 读取语法文件，处理它们，并提供一个方便的 API 来操作它们。它可能对那些直接操作语法或希望使用自定义类型解析器的人感兴趣。

以下是一个完整的示例代码，展示如何使用 cfgrammar 进行上下文无关文法解析与词法分析：

use cfgrammar::yacc::YaccKind;
use cfgrammar::{Grammar, Symbol};
use lrlex::DefaultLexerTypes;

fn main() {
    // 定义语法规则
    let grammar = r#"
        %start Expr
        %%
        Expr: Expr '+' Term | Term;
        Term: Term '*' Factor | Factor;
        Factor: 'id' | '(' Expr ')';
    "#;

    // 解析语法并构建 Grammar 对象
    let grm = Grammar::new(YaccKind::Original, grammar).unwrap();

    // 定义词法分析器
    let lexer = |input: &str| -> Vec<lrlex::LexToken<DefaultLexerTypes>> {
        let mut tokens = Vec::new();
        let mut chars = input.chars().peekable();
        let mut pos = 0;

        while let Some(c) = chars.next() {
            match c {
                ' ' | '\t' | '\n' => { pos += 1; } // 跳过空白字符
                '+' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::PLUS, pos, pos+1));
                    pos += 1;
                }
                '*' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::STAR, pos, pos+1));
                    pos += 1;
                }
                '(' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::LPAREN, pos, pos+1));
                    pos += 1;
                }
                ')' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::RPAREN, pos, pos+1));
                    pos += 1;
                }
                'a'..='z' | 'A'..='Z' => {
                    let start = pos;
                    while let Some(&nc) = chars.peek() {
                        if nc.is_alphabetic() {
                            chars.next();
                            pos += 1;
                        } else {
                            break;
                        }
                    }
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::ID, start, pos+1));
                    pos += 1;
                }
                _ => panic!("Unexpected character: {}", c),
            }
        }
        tokens
    };

    // 输入字符串
    let input = "id + id * id";

    // 进行词法分析
    let tokens = lexer(input);

    // 使用 Grammar 对象进行解析
    let parser = lrpar::LRParser::new(&grm);
    let result = parser.parse(&tokens);

    match result {
        Ok(ast) => {
            println!("Parse successful: {:?}", ast);
        }
        Err(e) => {
            println!("Parse error: {:?}", e);
        }
    }
}

以下是一个完整的示例代码，展示如何使用 cfgrammar 进行上下文无关文法解析与词法分析：

use cfgrammar::yacc::YaccKind;
use cfgrammar::{Grammar, Symbol};
use lrlex::DefaultLexerTypes;
use lrpar::LRParser;

fn main() {
    // 定义语法规则字符串
    let grammar = r#"
        %start Expr
        %%
        Expr: Expr '+' Term 
            | Term;
        Term: Term '*' Factor 
            | Factor;
        Factor: 'id' 
            | '(' Expr ')';
    "#;

    // 解析语法并构建 Grammar 对象，使用 Original Yacc 类型
    let grm = Grammar::new(YaccKind::Original, grammar).unwrap();

    // 定义词法分析器闭包函数
    let lexer = |input: &str| -> Vec<lrlex::LexToken<DefaultLexerTypes>> {
        let mut tokens = Vec::new(); // 存储词法标记的向量
        let mut chars = input.chars().peekable(); // 可窥视的字符迭代器
        let mut pos = 0; // 当前位置

        // 遍历输入字符串的所有字符
        while let Some(c) = chars.next() {
            match c {
                // 跳过空白字符（空格、制表符、换行符）
                ' ' | '\t' | '\n' => { 
                    pos += 1; 
                }
                // 处理加号运算符
                '+' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::PLUS, pos, pos+1));
                    pos += 1;
                }
                // 处理乘号运算符
                '*' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::STAR, pos, pos+1));
                    pos += 1;
                }
                // 处理左括号
                '(' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::LPAREN, pos, pos+1));
                    pos += 1;
                }
                // 处理右括号
                ')' => {
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::RPAREN, pos, pos+1));
                    pos += 1;
                }
                // 处理标识符（字母字符）
                'a'..='z' | 'A'..='Z' => {
                    let start = pos; // 记录标识符开始位置
                    // 连续读取字母字符直到非字母字符
                    while let Some(&nc) = chars.peek() {
                        if nc.is_alphabetic() {
                            chars.next();
                            pos += 1;
                        } else {
                            break;
                        }
                    }
                    // 添加标识符标记
                    tokens.push(lrlex::LexToken::new(DefaultLexerTypes::ID, start, pos+1));
                    pos += 1;
                }
                // 处理意外字符
                _ => panic!("Unexpected character: {}", c),
            }
        }
        tokens // 返回词法标记向量
    };

    // 定义输入字符串
    let input = "id + id * id";

    // 执行词法分析，将输入字符串转换为词法标记
    let tokens = lexer(input);

    // 创建 LALR 解析器实例
    let parser = LRParser::new(&grm);
    
    // 使用解析器解析词法标记
    let result = parser.parse(&tokens);

    // 处理解析结果
    match result {
        // 解析成功，输出抽象语法树
        Ok(ast) => {
            println!("Parse successful: {:?}", ast);
        }
        // 解析失败，输出错误信息
        Err(e) => {
            println!("Parse error: {:?}", e);
        }
    }
}