fst-reader 0.16.5

FST wavedump format reader implemented in safe Rust. Formerly known as fst-native.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// Copyright 2023 The Regents of the University of California
// Copyright 2024 Cornell University
// released under BSD 3-Clause License
// author: Kevin Laeufer <laeufer@cornell.edu>

use fst_reader::*;

pub fn hierarchy_to_str(entry: &FstHierarchyEntry) -> String {
    match entry {
        FstHierarchyEntry::Scope {
            name,
            tpe,
            component,
        } => format!("Scope: {name} ({}) {component}", hierarchy_tpe_to_str(tpe)),
        FstHierarchyEntry::UpScope => "UpScope".to_string(),
        FstHierarchyEntry::Var { name, handle, .. } => format!("({handle}): {name}"),
        FstHierarchyEntry::AttributeEnd => "EndAttr".to_string(),
        FstHierarchyEntry::PathName { name, id } => format!("PathName: {id} -> {name}"),
        FstHierarchyEntry::SourceStem {
            is_instantiation,
            path_id,
            line,
        } => format!("SourceStem:: {is_instantiation}, {path_id}, {line}"),
        FstHierarchyEntry::Comment { string } => format!("Comment: {string}"),
        FstHierarchyEntry::EnumTable {
            name,
            handle,
            mapping,
        } => {
            let names = mapping
                .iter()
                .map(|(_v, n)| n.clone())
                .collect::<Vec<_>>()
                .join(" ");
            let values = mapping
                .iter()
                .map(|(v, _n)| v.clone())
                .collect::<Vec<_>>()
                .join(" ");
            format!(
                "EnumTable: {name} {} {names} {values} ({handle})",
                mapping.len()
            )
        }
        FstHierarchyEntry::EnumTableRef { handle } => format!("EnumTableRef: {handle}"),
        FstHierarchyEntry::VhdlVarInfo {
            type_name,
            var_type,
            data_type,
        } => {
            format!("VHDL Var Info: {type_name}, {var_type:?}, {data_type:?}")
        }
        FstHierarchyEntry::Array {
            name,
            array_type,
            left,
            right,
        } => {
            let combined = ((*left as u64) << 32) | (*right as u64);
            format!("Array: {array_type:?} {name}: {combined}")
        }
        FstHierarchyEntry::Pack {
            name,
            pack_type,
            value,
        } => {
            format!("{pack_type:?} {name}: {value}")
        }
        FstHierarchyEntry::SVEnum {
            name,
            enum_type,
            value,
        } => {
            format!("SVEnum: {enum_type:?} {name}: {value}")
        }
    }
}

fn hierarchy_tpe_to_str(tpe: &FstScopeType) -> String {
    let con = match tpe {
        FstScopeType::Module => "Module",
        FstScopeType::Task => "Task",
        FstScopeType::Function => "Function",
        FstScopeType::Begin => "Begin",
        FstScopeType::Fork => "Fork",
        FstScopeType::Generate => "Generate",
        FstScopeType::Struct => "Struct",
        FstScopeType::Union => "Union",
        FstScopeType::Class => "Class",
        FstScopeType::Interface => "Interface",
        FstScopeType::Package => "Package",
        FstScopeType::Program => "Program",
        FstScopeType::VhdlArchitecture => "VhdlArchitecture",
        FstScopeType::VhdlProcedure => "VhdlProcedure",
        FstScopeType::VhdlFunction => "VhdlFunction",
        FstScopeType::VhdlRecord => "VhdlRecord",
        FstScopeType::VhdlProcess => "VhdlProcess",
        FstScopeType::VhdlBlock => "VhdlBlock",
        FstScopeType::VhdlForGenerate => "VhdlForGenerate",
        FstScopeType::VhdlIfGenerate => "VhdlIfGenerate",
        FstScopeType::VhdlGenerate => "VhdlGenerate",
        FstScopeType::VhdlPackage => "VhdlPackage",
        FstScopeType::AttributeBegin => "AttributeBegin",
        FstScopeType::AttributeEnd => "AttributeEnd",
        FstScopeType::VcdScope => "VcdScope",
        FstScopeType::VcdUpScope => "VcdUpScope",
        FstScopeType::SvArray => "SvArray",
    };
    con.to_string()
}