gpt

好的，下面是一个结合 logos 和 lalrpop 的完整 Rust 示例，展示了如何使用 logos 编写词法分析器（lexer），然后用 lalrpop 来解析语法，并生成 AST（抽象语法树）。这个示例将包括以下几个部分：

1. logos 词法分析器：用来从输入文本中生成 tokens。
2. lalrpop 语法分析器：用来解析这些 tokens，生成一个 AST。
3. AST 结构：用来表示解析后的数据结构。

步骤 1：依赖项

首先，在 Cargo.toml 中添加必要的依赖：

[dependencies]
lalrpop = "0.19"
logos = "0.12"

步骤 2：编写 lalrpop 语法文件

创建一个 src/parser.lalrpop 文件，并定义语法规则。假设我们正在处理一个简单的数学表达式解析器，支持加法和乘法。

// src/parser.lalrpop
grammar;

use crate::lexer::Token;

Expr: i64 = {
    Term "+" Expr => |lhs, _, rhs| lhs + rhs,
    Term => |x| x,
};

Term: i64 = {
    Factor "*" Term => |lhs, _, rhs| lhs * rhs,
    Factor => |x| x,
};

Factor: i64 = {
    Num => |x| x,
};

Num: i64 = r"[0-9]+" => |s: &str| s.parse::<i64>().unwrap();

步骤 3：编写 logos 词法分析器

在 src/lexer.rs 文件中，我们将使用 logos 来定义 token 及其正则表达式。

// src/lexer.rs
use logos::Logos;

#[derive(Debug, Logos, PartialEq, Clone)]
pub enum Token {
    #[regex(r"[0-9]+")]
    Num,

    #[token("+")]
    Plus,

    #[token("*")]
    Star,

    #[error]
    Error,
}

pub struct Lexer<'a> {
    lexer: logos::Lexer<'a, Token>,
}

impl<'a> Lexer<'a> {
    pub fn new(input: &'a str) -> Self {
        Lexer {
            lexer: Token::lexer(input),
        }
    }
}

impl<'a> Iterator for Lexer<'a> {
    type Item = Token;

    fn next(&mut self) -> Option<Self::Item> {
        self.lexer.next()
    }
}

步骤 4：定义 AST 结构

为了表示解析后的表达式，我们需要定义一个 AST 结构。我们将在 src/ast.rs 文件中定义。

// src/ast.rs
#[derive(Debug)]
pub enum Expr {
    Num(i64),
    Add(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
}

步骤 5：集成 lalrpop 和 logos

我们需要将 lalrpop 解析器与 logos 词法分析器连接起来。首先确保在 main.rs 中加载了 lalrpop 生成的解析器，并使用 Lexer 提供的 token 流。

// src/main.rs
mod lexer;
mod parser;
mod ast;

use lexer::{Lexer, Token};
use ast::Expr;
use lalrpop_util::parse_to_string;

fn main() {
    let input = "2 + 3 * 4 + 5";
    let lexer = Lexer::new(input);

    let mut lexer_iter = lexer.into_iter();
    let result = parser::ExprParser::new().parse(&mut lexer_iter);

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

步骤 6：让 lalrpop 与 logos 协同工作

现在我们需要在 src/parser.rs 文件中实现 lalrpop 解析器，使用 Lexer 中的 tokens。

// src/parser.rs
use lalrpop_util::lalrpop_mod;
use crate::lexer::Token;
use crate::ast::Expr;

lalrpop_mod!(pub parser); // This will generate a `parser` module with the `ExprParser`

pub struct ExprParser;

impl ExprParser {
    pub fn new() -> Self {
        ExprParser {}
    }

    pub fn parse<'a>(&self, lexer: &mut impl Iterator<Item = Token>) -> Result<Expr, &'static str> {
        let tokens: Vec<Token> = lexer.collect();
        let mut lexer = tokens.into_iter();

        parser::ExprParser::new().parse(&mut lexer).map_err(|_| "Parse error")
    }
}

步骤 7：构建和运行

在编译和运行之前，确保你的项目结构正确：

src/
├── ast.rs
├── lexer.rs
├── main.rs
└── parser.lalrpop

在终端中运行：

cargo run

解释：

• lexer.rs 定义了词法分析器，使用 logos 来匹配数字、加号和乘号。
• parser.lalrpop 定义了基本的加法和乘法规则，将其解析为 i64 类型的值。
• ast.rs 定义了 AST 结构，用来表示解析后的表达式。
• main.rs 负责集成 lexer 和 parser，将词法分析器生成的 token 流传递给 lalrpop 解析器。

执行结果

给定输入 "2 + 3 * 4 + 5"，解析器会生成如下的 AST 结构：

Parsed AST: Add(
    Box::new(Num(2)),
    Box::new(Add(
        Box::new(Mul(Box::new(Num(3)), Box::new(Num(4)))),
        Box::new(Num(5)),
    )),
)

这表示表达式的树形结构：2 + (3 * 4) + 5。

这样，你就完成了 logos 和 lalrpop 的结合，并生成了一个简单的 AST 解析器。