wavepeek 0.5.0

Command-line tool for RTL waveform inspection with deterministic machine-friendly output.
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

use crate::expr::diagnostic::ExprDiagnostic;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SignalHandle(pub u32);

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IntegerLikeKind {
    Byte,
    Shortint,
    Int,
    Longint,
    Integer,
    Time,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExprTypeKind {
    BitVector,
    IntegerLike(IntegerLikeKind),
    EnumCore,
    Real,
    String,
    Event,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExprStorage {
    PackedVector,
    Scalar,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EnumLabelInfo {
    pub name: String,
    pub bits: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExprType {
    pub kind: ExprTypeKind,
    pub storage: ExprStorage,
    pub width: u32,
    pub is_four_state: bool,
    pub is_signed: bool,
    pub enum_type_id: Option<String>,
    pub enum_labels: Option<Vec<EnumLabelInfo>>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum SampledValue {
    Integral {
        bits: Option<String>,
        label: Option<String>,
    },
    Real {
        value: Option<f64>,
    },
    String {
        value: Option<String>,
    },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EventEvalFrame<'a> {
    pub timestamp: u64,
    pub previous_timestamp: Option<u64>,
    pub tracked_signals: &'a [SignalHandle],
}

pub trait ExpressionHost {
    fn resolve_signal(&self, name: &str) -> Result<SignalHandle, ExprDiagnostic>;
    fn signal_type(&self, handle: SignalHandle) -> Result<ExprType, ExprDiagnostic>;
    /// Returns the sampled signal state at or before `timestamp`.
    ///
    /// `None` inside the returned payload means no sampled state exists at or
    /// before this timestamp.
    ///
    /// Raw `event` operands are not sampled through this method.
    fn sample_value(
        &self,
        handle: SignalHandle,
        timestamp: u64,
    ) -> Result<SampledValue, ExprDiagnostic>;

    /// Returns whether a raw `event` operand occurred at `timestamp`.
    ///
    /// Non-event operands are not queried through this method.
    fn event_occurred(&self, handle: SignalHandle, timestamp: u64) -> Result<bool, ExprDiagnostic>;
}