sv-parser

完全符合 IEEE 1800-2017 的 SystemVerilog 解析库。

使用 sv-parser 的工具

• morty: SystemVerilog 源文件 pickler
• svinst: 确定在 SystemVerilog 文件中声明的和实例化的模块
• svlint: SystemVerilog 代码检查工具
• svls: SystemVerilog 语言服务器

使用方法

[dependencies]
sv-parser = "0.13.3"

sv-parser 提供了返回 parse_sv 函数，它返回 SyntaxTree。 SyntaxTree 显示具体的语法树。它包含预处理后的字符串和解析后的树。

RefNode 显示对 SyntaxTree 中任何节点的引用。您可以通过 SyntaxTree 的迭代器获取 RefNode。 RefNode 的变体名称遵循 IEEE 1800-2017 的“附件A正式语法”。

Locate 显示标记的位置。 SyntaxTree 的所有叶节点都是 Locate。您可以通过 get_str 从 Locate 获取字符串。

示例

以下示例解析了 SystemVerilog 源文件并显示了模块名称。

use std::collections::HashMap;
use std::env;
use std::path::PathBuf;
use sv_parser::{parse_sv, unwrap_node, Locate, RefNode};

fn main() {
    let args: Vec<String> = env::args().collect();

    // The path of SystemVerilog source file
    let path = PathBuf::from(&args[1]);
    // The list of defined macros
    let defines = HashMap::new();
    // The list of include paths
    let includes: Vec<PathBuf> = Vec::new();

    // Parse
    let result = parse_sv(&path, &defines, &includes, false, false);

    if let Ok((syntax_tree, _)) = result {
        // &SyntaxTree is iterable
        for node in &syntax_tree {
            // The type of each node is RefNode
            match node {
                RefNode::ModuleDeclarationNonansi(x) => {
                    // unwrap_node! gets the nearest ModuleIdentifier from x
                    let id = unwrap_node!(x, ModuleIdentifier).unwrap();

                    let id = get_identifier(id).unwrap();

                    // Original string can be got by SyntaxTree::get_str(self, locate: &Locate)
                    let id = syntax_tree.get_str(&id).unwrap();
                    println!("module: {}", id);
                }
                RefNode::ModuleDeclarationAnsi(x) => {
                    let id = unwrap_node!(x, ModuleIdentifier).unwrap();
                    let id = get_identifier(id).unwrap();
                    let id = syntax_tree.get_str(&id).unwrap();
                    println!("module: {}", id);
                }
                _ => (),
            }
        }
    } else {
        println!("Parse failed");
    }
}

fn get_identifier(node: RefNode) -> Option<Locate> {
    // unwrap_node! can take multiple types
    match unwrap_node!(node, SimpleIdentifier, EscapedIdentifier) {
        Some(RefNode::SimpleIdentifier(x)) => {
            return Some(x.nodes.0);
        }
        Some(RefNode::EscapedIdentifier(x)) => {
            return Some(x.nodes.0);
        }
        _ => None,
    }
}

许可证

许可协议为以下之一

• Apache License，版本 2.0，(LICENSE-APACHE 或 https://apache.ac.cn/licenses/LICENSE-2.0)
• 麻省理工学院许可证（LICENSE-MIT 或 http://opensource.org/licenses/MIT）

由你选择。

贡献

除非你明确声明，否则根据Apache-2.0许可证定义的，你提交的旨在包含在作品中的任何贡献，将按照上述方式双许可，不附加任何额外条款或条件。