Enum moore_svlog::hir::StmtKind

pub enum StmtKind {
    Null,
    Block(Vec<NodeId>),
    Assign {
        lhs: NodeId,
        rhs: NodeId,
        kind: AssignKind,
    },
    Timed {
        control: TimingControl,
        stmt: NodeId,
    },
    Expr(NodeId),
    If {
        cond: NodeId,
        main_stmt: NodeId,
        else_stmt: Option<NodeId>,
    },
    Loop {
        kind: LoopKind,
        body: NodeId,
    },
    InlineGroup {
        stmts: Vec<NodeId>,
        rib: NodeId,
    },
    Case {
        expr: NodeId,
        ways: Vec<(Vec<NodeId>, NodeId)>,
        default: Option<NodeId>,
        kind: CaseKind,
    },
}

The different forms a statement can take.

Variants

Null

A null statement.

Block(Vec<NodeId>)

A sequential block.

Tuple Fields of Block

0: Vec<NodeId>

Assign

An assign statement (blocking or non-blocking).

Fields of Assign

lhs: NodeIdrhs: NodeIdkind: AssignKind

Timed

A statement with timing control.

Fields of Timed

control: TimingControlstmt: NodeId

Expr(NodeId)

An expression statement.

Tuple Fields of Expr

0: NodeId

If

An if statement.

if (<cond>) <main_stmt> [else <else_stmt>]

Fields of If

cond: NodeIdmain_stmt: NodeIdelse_stmt: Option<NodeId>

Loop

A loop statement.

Fields of Loop

kind: LoopKindbody: NodeId

InlineGroup

An inline group of statements.

This is a special node that is used for example with variable declarations, where one statement can generate multiple nodes referrable by name. An inline group differs from a block in that its ribs are made visible, whereas a block keeps them local.

Fields of InlineGroup

stmts: Vec<NodeId>rib: NodeId

Case

A case statement.

Fields of Case

expr: NodeIdways: Vec<(Vec<NodeId>, NodeId)>default: Option<NodeId>kind: CaseKind

Trait Implementations

impl Clone for StmtKind

fn clone(&self) -> StmtKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StmtKind

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

Formats the value using the given formatter.

impl PartialEq<StmtKind> for StmtKind

fn eq(&self, other: &StmtKind) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Eq for StmtKind

impl StructuralEq for StmtKind

impl StructuralPartialEq for StmtKind