miden-assembly-syntax 0.22.1

Parsing and semantic analysis of the Miden Assembly language
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

use core::fmt;

use miden_debug_types::{SourceSpan, Span, Spanned};

use super::{Block, Immediate, Instruction};

/// Represents the Miden Assembly instruction set syntax
///
/// This is separate from [Instruction] in order to distinguish control flow instructions and
/// instructions with block regions from the rest.
#[derive(Clone)]
#[repr(u8)]
pub enum Op {
    /// Represents a conditional branch
    ///
    /// Can be either `if`..`end`, or `if`..`else`..`end`.
    If {
        span: SourceSpan,
        /// This block is always present and non-empty
        then_blk: Block,
        /// This block will be empty if no `else` branch was present
        else_blk: Block,
    } = 0,
    /// Represents a condition-controlled loop
    While { span: SourceSpan, body: Block } = 1,
    /// Represents a counter-controlled loop.
    ///
    /// NOTE: The iteration count must be known at compile-time, so this is _not_ used for general
    /// `for`-style loops where the iteration count is dynamic.
    /// Also, it may be either a literal value or constant name (e.g. `add.1` or `add.CONST`)
    Repeat {
        span: SourceSpan,
        count: Immediate<u32>,
        body: Block,
    } = 2,
    /// A primitive operation, e.g. `add`
    Inst(Span<Instruction>) = 3,
}

impl crate::prettier::PrettyPrint for Op {
    fn render(&self) -> crate::prettier::Document {
        use crate::prettier::*;

        match self {
            Self::If { then_blk, else_blk, .. } => {
                text("if.true") + then_blk.render() + text("else") + else_blk.render() + text("end")
            },
            Self::While { body, .. } => text("while.true") + body.render() + text("end"),
            Self::Repeat { count, body, .. } => {
                display(format!("repeat.{count}")) + body.render() + text("end")
            },
            Self::Inst(inst) => inst.render(),
        }
    }
}

impl fmt::Debug for Op {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::If { then_blk, else_blk, .. } => {
                f.debug_struct("If").field("then", then_blk).field("else", else_blk).finish()
            },
            Self::While { body, .. } => f.debug_tuple("While").field(body).finish(),
            Self::Repeat { count, body, .. } => {
                f.debug_struct("Repeat").field("count", count).field("body", body).finish()
            },
            Self::Inst(inst) => fmt::Debug::fmt(&**inst, f),
        }
    }
}

impl Eq for Op {}

impl PartialEq for Op {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (
                Self::If { then_blk: lt, else_blk: le, .. },
                Self::If { then_blk: rt, else_blk: re, .. },
            ) => lt == rt && le == re,
            (Self::While { body: lbody, .. }, Self::While { body: rbody, .. }) => lbody == rbody,
            (
                Self::Repeat { count: lcount, body: lbody, .. },
                Self::Repeat { count: rcount, body: rbody, .. },
            ) => lcount == rcount && lbody == rbody,
            (Self::Inst(l), Self::Inst(r)) => l == r,
            _ => false,
        }
    }
}

impl Spanned for Op {
    fn span(&self) -> SourceSpan {
        match self {
            Self::If { span, .. } | Self::While { span, .. } | Self::Repeat { span, .. } => *span,
            Self::Inst(spanned) => spanned.span(),
        }
    }
}