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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::core::ast::{Verilog, VerilogExpression};
use crate::core::atom::{Atom, AtomKind};
use crate::core::block::Block;
use crate::core::check_error::{CheckError, PathedName, PathedNameList};
use crate::core::prelude::SimError::Check;
use crate::core::prelude::{NamedPath, VerilogVisitor};
use crate::core::probe::Probe;
use std::collections::HashSet;

#[derive(Copy, Clone, Debug, PartialEq)]
enum Mode {
    Ignore,
    Read,
    Write,
}

struct VerilogWriteCollector {
    vars_written: HashSet<String>,
    vars_read: HashSet<String>,
    mode: Mode,
}

impl Default for VerilogWriteCollector {
    fn default() -> Self {
        Self {
            vars_written: Default::default(),
            vars_read: Default::default(),
            mode: Mode::Ignore,
        }
    }
}

fn get_write_list(uut: &dyn Block) -> HashSet<String> {
    match &uut.hdl() {
        Verilog::Combinatorial(code) => {
            let mut det = VerilogWriteCollector::default();
            det.visit_block(code);
            det.vars_written
        }
        _ => Default::default(),
    }
}

impl VerilogVisitor for VerilogWriteCollector {
    fn visit_slice_assignment(
        &mut self,
        base: &VerilogExpression,
        _width: &usize,
        offset: &VerilogExpression,
        replacement: &VerilogExpression,
    ) {
        let current_mode = self.mode;
        self.mode = Mode::Read;
        self.visit_expression(offset);
        self.visit_expression(replacement);
        self.mode = Mode::Write;
        self.visit_expression(base);
        self.mode = current_mode;
    }

    fn visit_signal(&mut self, c: &str) {
        let myname = c.replace("$next", "");
        match self.mode {
            Mode::Ignore => {}
            Mode::Write => {
                self.vars_written.insert(myname);
            }
            Mode::Read => {
                self.vars_read.insert(myname);
            }
        }
    }

    fn visit_assignment(&mut self, l: &VerilogExpression, r: &VerilogExpression) {
        let current_mode = self.mode;
        self.mode = Mode::Read;
        self.visit_expression(r);
        self.mode = Mode::Write;
        self.visit_expression(l);
        self.mode = current_mode;
    }
}

#[derive(Default)]
struct CheckInputsNotDriven {
    path: NamedPath,
    namespace: NamedPath,
    input_parameters: Vec<Vec<String>>,
    failures: PathedNameList,
}

impl Probe for CheckInputsNotDriven {
    fn visit_start_scope(&mut self, name: &str, _node: &dyn Block) {
        self.input_parameters.push(vec![]);
        self.path.push(name);
        self.namespace.reset();
    }

    fn visit_start_namespace(&mut self, name: &str, _node: &dyn Block) {
        self.namespace.push(name);
    }

    fn visit_atom(&mut self, name: &str, signal: &dyn Atom) {
        let namespace = self.namespace.flat("$");
        let name = if namespace.is_empty() {
            name.to_owned()
        } else {
            format!("{}${}", namespace, name)
        };
        match signal.kind() {
            AtomKind::InputParameter => {
                self.input_parameters.last_mut().unwrap().push(name);
            }
            _ => {}
        }
    }

    fn visit_end_namespace(&mut self, _name: &str, _node: &dyn Block) {
        self.namespace.pop();
    }

    fn visit_end_scope(&mut self, _name: &str, node: &dyn Block) {
        let written = get_write_list(node);
        let my_params = self.input_parameters.last().unwrap();
        for param in my_params {
            if written.contains(param) {
                self.failures.push(PathedName {
                    path: self.path.to_string(),
                    name: param.to_owned(),
                })
            }
        }
        self.path.pop();
        self.input_parameters.pop();
    }
}

pub fn check_inputs_not_written(uut: &dyn Block) -> Result<(), CheckError> {
    let mut visitor = CheckInputsNotDriven::default();
    uut.accept("uut", &mut visitor);
    if visitor.failures.is_empty() {
        Ok(())
    } else {
        Err(CheckError::WritesToInputs(visitor.failures))
    }
}