topstitch 0.96.0

Stitch together Verilog modules with Rust
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

// SPDX-License-Identifier: Apache-2.0

use slang_rs::SlangConfig;

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub(crate) struct ParserConfigOwnedKey {
    pub(crate) sources: Vec<String>,
    pub(crate) tops: Vec<String>,
    pub(crate) incdirs: Vec<String>,
    pub(crate) defines: Vec<(String, String)>,
    pub(crate) parameters: Vec<(String, String)>,
    pub(crate) libfiles: Vec<String>,
    pub(crate) libdirs: Vec<String>,
    pub(crate) libexts: Vec<String>,
    pub(crate) ignore_unknown_modules: bool,
    pub(crate) ignore_protected: bool,
    pub(crate) timescale: Option<String>,
    pub(crate) skip_unsupported: bool,
    pub(crate) include_hierarchy: bool,
    pub(crate) extra_arguments: Vec<String>,
}

#[derive(Debug)]
pub struct ParserConfig<'a> {
    pub sources: &'a [&'a str],
    pub tops: &'a [&'a str],
    pub incdirs: &'a [&'a str],
    pub defines: &'a [(&'a str, &'a str)],
    pub parameters: &'a [(&'a str, &'a str)],
    pub libfiles: &'a [&'a str],
    pub libdirs: &'a [&'a str],
    pub libexts: &'a [&'a str],
    pub ignore_unknown_modules: bool,
    pub ignore_protected: bool,
    pub timescale: Option<&'a str>,
    pub skip_unsupported: bool,
    pub include_hierarchy: bool,
    pub extra_arguments: &'a [&'a str],
}

impl Default for ParserConfig<'_> {
    fn default() -> Self {
        ParserConfig {
            sources: &[],
            tops: &[],
            incdirs: &[],
            defines: &[],
            parameters: &[],
            libfiles: &[],
            libdirs: &[],
            libexts: &[],
            ignore_unknown_modules: true,
            ignore_protected: true,
            timescale: None,
            skip_unsupported: false,
            include_hierarchy: false,
            extra_arguments: &[],
        }
    }
}

impl ParserConfig<'_> {
    pub fn to_slang_config(&self) -> SlangConfig<'_> {
        SlangConfig {
            sources: self.sources,
            tops: self.tops,
            incdirs: self.incdirs,
            defines: self.defines,
            parameters: self.parameters,
            libfiles: self.libfiles,
            libdirs: self.libdirs,
            libexts: self.libexts,
            ignore_unknown_modules: self.ignore_unknown_modules,
            ignore_protected: self.ignore_protected,
            timescale: self.timescale,
            extra_arguments: self.extra_arguments,
        }
    }

    pub(crate) fn to_owned_key(&self) -> ParserConfigOwnedKey {
        ParserConfigOwnedKey {
            sources: self.sources.iter().map(|s| (*s).to_string()).collect(),
            tops: self.tops.iter().map(|s| (*s).to_string()).collect(),
            incdirs: self.incdirs.iter().map(|s| (*s).to_string()).collect(),
            defines: self
                .defines
                .iter()
                .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
                .collect(),
            parameters: self
                .parameters
                .iter()
                .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
                .collect(),
            libfiles: self.libfiles.iter().map(|s| (*s).to_string()).collect(),
            libdirs: self.libdirs.iter().map(|s| (*s).to_string()).collect(),
            libexts: self.libexts.iter().map(|s| (*s).to_string()).collect(),
            ignore_unknown_modules: self.ignore_unknown_modules,
            ignore_protected: self.ignore_protected,
            timescale: self.timescale.map(|t| t.to_string()),
            skip_unsupported: self.skip_unsupported,
            include_hierarchy: self.include_hierarchy,
            extra_arguments: self
                .extra_arguments
                .iter()
                .map(|s| (*s).to_string())
                .collect(),
        }
    }
}