Enum TestbenchStatement 

pub enum TestbenchStatement<Event, Signal, Expression, Argument, Target = Signal> {
    ClockNext {
        clock_event: Event,
        count: ClockCount<Expression>,
    },
    ResetAssert {
        reset_signal: Signal,
        reset_event: Option<Event>,
        clock_event: Event,
        duration: ClockCount<Expression>,
        assert_value: u8,
        deassert_value: u8,
    },
    Assert {
        expr: Expression,
        site_id: u32,
        continue_on_fail: bool,
        message: Option<AssertMessage<Argument>>,
        location: Option<SourceLocation>,
    },
    Display {
        message: Option<AssertMessage<Argument>>,
        newline: bool,
    },
    If {
        expr: Expression,
        then_block: Vec<Self>,
        else_block: Vec<Self>,
    },
    For {
        loop_var: Option<(Signal, usize, bool)>,
        start: LoopBound<Expression>,
        end: LoopBound<Expression>,
        inclusive: bool,
        step: usize,
        step_op: Option<TestbenchOperator>,
        reverse: bool,
        body: Vec<Self>,
    },
    Assign {
        dst: Target,
        expr: Expression,
    },
    RandomSeed {
        handle: String,
        value: Expression,
    },
    RandomGet {
        handle: String,
        width: u32,
        signed: bool,
        ret: Option<Target>,
    },
    RandomGetRange {
        handle: String,
        min: Expression,
        max: Expression,
        width: u32,
        signed: bool,
        ret: Option<Target>,
    },
    RandomGetSeed {
        handle: String,
        ret: Option<Target>,
    },
    ComponentMethod {
        instance: String,
        method: String,
        args: Vec<Argument>,
        ret: Option<Target>,
        ret_width: Option<u32>,
        ret_signed: bool,
        ret_strict: bool,
    },
    Break,
    Finish,
}

Source-independent testbench control program.

Frontends instantiate this with semantic state/event identities and unbound expressions. Runtime binding instantiates the same contract with backend event/signal handles and executable expressions.

Variants

ClockNext

Fields

clock_event: Event

count: ClockCount<Expression>

ResetAssert

Fields

reset_signal: Signal

reset_event: Option<Event>

clock_event: Event

duration: ClockCount<Expression>

assert_value: u8

deassert_value: u8

Assert

Fields

expr: Expression

site_id: u32

continue_on_fail: bool

message: Option<AssertMessage<Argument>>

location: Option<SourceLocation>

Display

Fields

message: Option<AssertMessage<Argument>>

newline: bool

If

Fields

expr: Expression

then_block: Vec<Self>

else_block: Vec<Self>

For

Fields

loop_var: Option<(Signal, usize, bool)>

start: LoopBound<Expression>

end: LoopBound<Expression>

inclusive: bool

step: usize

step_op: Option<TestbenchOperator>

reverse: bool

body: Vec<Self>

Assign

Fields

dst: Target

expr: Expression

RandomSeed

Fields

handle: String

value: Expression

RandomGet

Fields

handle: String

width: u32

signed: bool

ret: Option<Target>

RandomGetRange

Fields

handle: String

min: Expression

max: Expression

width: u32

signed: bool

ret: Option<Target>

RandomGetSeed

Fields

handle: String

ret: Option<Target>

ComponentMethod

Fields

instance: String

method: String

args: Vec<Argument>

ret: Option<Target>

ret_width: Option<u32>

ret_signed: bool

ret_strict: bool

Break

Finish

Trait Implementations

impl<Event: Clone, Signal: Clone, Expression: Clone, Argument: Clone, Target: Clone> Clone for TestbenchStatement<Event, Signal, Expression, Argument, Target>

fn clone( &self, ) -> TestbenchStatement<Event, Signal, Expression, Argument, Target>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Event: Debug, Signal: Debug, Expression: Debug, Argument: Debug, Target: Debug> Debug for TestbenchStatement<Event, Signal, Expression, Argument, Target>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, Event, Signal, Expression, Argument, Target> Deserialize<'de> for TestbenchStatement<Event, Signal, Expression, Argument, Target>

where Event: Deserialize<'de>, Signal: Deserialize<'de>, Expression: Deserialize<'de>, Argument: Deserialize<'de>, Target: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Event: Eq, Signal: Eq, Expression: Eq, Argument: Eq, Target: Eq> Eq for TestbenchStatement<Event, Signal, Expression, Argument, Target>

impl<Event: PartialEq, Signal: PartialEq, Expression: PartialEq, Argument: PartialEq, Target: PartialEq> PartialEq for TestbenchStatement<Event, Signal, Expression, Argument, Target>

fn eq( &self, other: &TestbenchStatement<Event, Signal, Expression, Argument, Target>, ) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Event, Signal, Expression, Argument, Target> Serialize for TestbenchStatement<Event, Signal, Expression, Argument, Target>

where Event: Serialize, Signal: Serialize, Expression: Serialize, Argument: Serialize, Target: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Event: PartialEq, Signal: PartialEq, Expression: PartialEq, Argument: PartialEq, Target: PartialEq> StructuralPartialEq for TestbenchStatement<Event, Signal, Expression, Argument, Target>