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

// Original file: "Ops.hs"
// File auto-generated using Corollary.

#[macro_use]
use corollary_support::*;

// NOTE: These imports are advisory. You probably need to change them to support Rust.
// use Data::Generics;

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum CAssignOp {
    CAssignOp,
    CMulAssOp,
    CDivAssOp,
    CRmdAssOp,
    CAddAssOp,
    CSubAssOp,
    CShlAssOp,
    CShrAssOp,
    CAndAssOp,
    CXorAssOp,
    COrAssOp,
}
pub use self::CAssignOp::*;

pub fn assignBinop(_0: CAssignOp) -> CBinaryOp {
    match (_0) {
        CAssignOp => __error!("direct assignment has no binary operator".to_string()),
        CMulAssOp => CMulOp,
        CDivAssOp => CDivOp,
        CRmdAssOp => CRmdOp,
        CAddAssOp => CAddOp,
        CSubAssOp => CSubOp,
        CShlAssOp => CShlOp,
        CShrAssOp => CShrOp,
        CAndAssOp => CAndOp,
        CXorAssOp => CXorOp,
        COrAssOp => COrOp,
    }
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum CBinaryOp {
    CMulOp,
    CDivOp,
    CRmdOp,
    CAddOp,
    CSubOp,
    CShlOp,
    CShrOp,
    CLeOp,
    CGrOp,
    CLeqOp,
    CGeqOp,
    CEqOp,
    CNeqOp,
    CAndOp,
    CXorOp,
    COrOp,
    CLndOp,
    CLorOp,
}
pub use self::CBinaryOp::*;

pub fn isCmpOp(op: CBinaryOp) -> bool {
    elem(op, vec![CLeqOp, CGeqOp, CLeOp, CGrOp, CEqOp, CNeqOp])
}

pub fn isPtrOp(op: CBinaryOp) -> bool {
    elem(op, vec![CAddOp, CSubOp])
}

pub fn isBitOp(op: CBinaryOp) -> bool {
    elem(op, vec![CShlOp, CShrOp, CAndOp, COrOp, CXorOp])
}

pub fn isLogicOp(op: CBinaryOp) -> bool {
    elem(op, vec![CLndOp, CLorOp])
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum CUnaryOp {
    CPreIncOp,
    CPreDecOp,
    CPostIncOp,
    CPostDecOp,
    CAdrOp,
    CIndOp,
    CPlusOp,
    CMinOp,
    CCompOp,
    CNegOp,
}
pub use self::CUnaryOp::*;

pub fn isEffectfulOp(op: CUnaryOp) -> bool {
    elem(op, vec![CPreIncOp, CPreDecOp, CPostIncOp, CPostDecOp])
}