hoodlum-parser 0.5.0

Parser for the hoodlum crate.
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

use std::collections::BTreeSet;

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct Code(pub Vec<Toplevel>);

pub type Arg = (Ident, Dir, Option<i32>);

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Toplevel {
    Entity(Ident, Vec<Arg>),
    Impl(Ident, Vec<Decl>),
    VerilogLiteral(String),
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct Ident(pub String);

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Dir {
    In,
    Out,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Edge {
    Pos,
    Neg,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct EdgeRef(pub Ident, pub Edge);

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Decl {
    Latch(Ident, Vec<Expr>),
    Reg(Ident, Vec<Expr>, Option<Expr>),
    Let(Ident, Ident, Vec<(Ident, Expr)>),
    Const(Ident, Expr),
    On(EdgeRef, SeqBlock),
    Always(SeqBlock),
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct SeqBlock(pub Vec<Seq>);

#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub enum BlockType {
    Blocking,
    NonBlocking,
    Static,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Seq {
    If(Expr, SeqBlock, Option<SeqBlock>),
    Set(BlockType, Ident, Expr),
    SetIndex(BlockType, Ident, Expr, Expr),
    SetRange(BlockType, Ident, Expr, Expr, Expr),
    Match(Expr, Vec<(Vec<Expr>, SeqBlock)>),

    While(Expr, SeqBlock),
    Loop(SeqBlock),
    Async(SeqBlock),
    FsmCaseTransition(Ident),
    Fsm(Vec<(Ident, SeqBlock)>),
    Yield,
    Await(Expr),

    FsmCase(Vec<(Vec<i32>, SeqBlock)>),
    FsmTransition(u32),
}

//#[derive(Clone, Debug, Eq, Hash, PartialEq)]
//pub struct CombBlock(pub Vec<Comb>);
//
//#[derive(Clone, Debug, Eq, Hash, PartialEq)]
//pub enum Comb {
//    If(Expr, CombBlock, Option<CombBlock>),
//    Assign(Ident, Expr),
//}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Op {
    Add,
    Sub,
    Mul,
    Div,
    Eq,
    Lte,
    Gte,
    And,
    Or,
    Lt,
    Gt,
    Ne,
    BinOr,
    BinAnd,
    LShift,
    RShift,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum UnaryOp {
    Not,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Expr {
    Ref(Ident),
    Slice(Ident, Box<Expr>, Option<Box<Expr>>),
    Ternary(Box<Expr>, Box<Expr>, Box<Expr>),
    Concat(Vec<Expr>),
    Repeat(Box<Expr>, Box<Expr>),
    Arith(Op, Box<Expr>, Box<Expr>),
    Unary(UnaryOp, Box<Expr>),
    Num(i32),
    Placeholder,

    FsmEq(BTreeSet<i32>),
    FsmNe(BTreeSet<i32>),
}

impl Expr {
    pub fn to_i32(&self) -> i32 {
        match *self {
            Expr::Num(value) => value,
            _ => {
                panic!("Called to_i32 on non-Num.")
            }
        }
    }
}