protospec-build 0.3.0

One binary format language to rule them all, One binary format language to find them, One binary format language to bring them all and in the darkness bind them.
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

use super::*;

mod binary;
pub use binary::*;

mod unary;
pub use unary::*;

mod cast;
pub use cast::*;

mod array_index;
pub use array_index::*;

mod enum_access;
pub use enum_access::*;

mod ternary;
pub use ternary::*;

mod call;
pub use call::*;

mod ident;
pub use ident::*;

mod string;
pub use string::*;

mod int;
pub use int::*;

mod boolean;
pub use boolean::*;

mod member;
pub use member::*;

#[derive(Clone, Serialize, Deserialize)]
pub enum Expression {
    Binary(BinaryExpression),
    Unary(UnaryExpression),
    Cast(CastExpression),
    ArrayIndex(ArrayIndexExpression),
    EnumAccess(EnumAccessExpression),
    Int(Int),
    Ref(Ident),
    Str(Str),
    Ternary(TernaryExpression),
    Bool(Bool),
    Call(CallExpression),
    Member(MemberExpression),
}

impl Node for Expression {
    fn span(&self) -> &Span {
        match self {
            Expression::Binary(x) => x.span(),
            Expression::Unary(x) => x.span(),
            Expression::Cast(x) => x.span(),
            Expression::ArrayIndex(x) => x.span(),
            Expression::EnumAccess(x) => x.span(),
            Expression::Int(x) => x.span(),
            Expression::Ref(x) => x.span(),
            Expression::Str(x) => x.span(),
            Expression::Ternary(x) => x.span(),
            Expression::Bool(x) => x.span(),
            Expression::Call(x) => x.span(),
            Expression::Member(x) => x.span(),
        }
    }
}