seax_scheme 0.3.0

Scheme compiler for the Seax VM.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

use super::*;
use super::NumNode::*;
use super::ExprNode::*;

use svm::cell::Atom::*;
use svm::cell::Inst::*;
use svm::cell::SVMCell::*;

use svm::slist::List::{Cons,Nil};

#[test]
fn test_compile_add() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "+".to_string() }),
        operands: vec![
            NumConst(IntConst(IntNode{ value: 1 })),
            NumConst(IntConst(IntNode{ value: 2 }))
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(SInt(2)),
            InstCell(LDC), AtomCell(SInt(1)),
            InstCell(ADD)
        ])
    )
}

#[test]
fn test_compile_sub() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "-".to_string() }),
        operands: vec![
            NumConst(UIntConst(UIntNode{ value: 9 })),
            NumConst(UIntConst(UIntNode{ value: 9 })),
            NumConst(UIntConst(UIntNode{ value: 9 }))
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(UInt(9)),
            InstCell(LDC), AtomCell(UInt(9)),
            InstCell(SUB),
            InstCell(LDC), AtomCell(UInt(9)),
            InstCell(SUB)
        ])
    )
}

#[test]
fn test_compile_div() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "/".to_string() }),
        operands: vec![
            NumConst(IntConst(IntNode{ value: 1 })),
            NumConst(IntConst(IntNode{ value: 2 })),
            NumConst(IntConst(IntNode{ value: 3 })),
            NumConst(IntConst(IntNode{ value: 4 }))
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(SInt(4)),
            InstCell(LDC), AtomCell(SInt(3)),
            InstCell(DIV),
            InstCell(LDC), AtomCell(SInt(2)),
            InstCell(DIV),
            InstCell(LDC), AtomCell(SInt(1)),
            InstCell(DIV)

        ])
    )
}

#[test]
fn test_compile_mul() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "*".to_string() }),
        operands: vec![
            NumConst(FloatConst(FloatNode{ value: 1f64 })),
            NumConst(FloatConst(FloatNode{ value: 2f64 })),
            NumConst(FloatConst(FloatNode{ value: 3f64 })),
            NumConst(FloatConst(FloatNode{ value: 4f64 }))
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(Float(4f64)),
            InstCell(LDC), AtomCell(Float(3f64)),
            InstCell(MUL),
            InstCell(LDC), AtomCell(Float(2f64)),
            InstCell(MUL),
            InstCell(LDC), AtomCell(Float(1f64)),
            InstCell(MUL)
        ])
    )
}

#[test]
fn test_compile_nested_sexpr() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "+".to_string() }),
        operands: vec![
            NumConst(IntConst(IntNode{ value: 4 })),
            SExpr(SExprNode {
                operator: box Name(NameNode { name: "-".to_string() }),
                operands: vec![
                    NumConst(IntConst(IntNode{ value: 1 })),
                    NumConst(IntConst(IntNode{ value: 2 })),
                    NumConst(IntConst(IntNode{ value: 3 }))
                ]
            })
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(SInt(3)),
            InstCell(LDC), AtomCell(SInt(2)),
            InstCell(SUB),
            InstCell(LDC), AtomCell(SInt(1)),
            InstCell(SUB),
            InstCell(LDC), AtomCell(SInt(4)),
            InstCell(ADD)
        ])
    )
}

#[test]
fn test_compile_gte() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: ">=".to_string() }),
        operands: vec![
            NumConst(FloatConst(FloatNode{ value: 1f64 })),
            NumConst(IntConst(IntNode{ value: 2 })),
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(SInt(2)),
            InstCell(LDC), AtomCell(Float(1f64)),
            InstCell(GTE)
        ])
    )
}

#[test]
fn test_compile_lte() {
    let ast = SExprNode {
        operator: box Name(NameNode { name: "<=".to_string() }),
        operands: vec![
            NumConst(UIntConst(UIntNode{ value: 3 })),
            NumConst(IntConst(IntNode{ value: 2 })),
        ]
    };
    assert_eq!(
        ast.compile(&SymTable::new()),
        Ok(vec![
            InstCell(LDC), AtomCell(SInt(2)),
            InstCell(LDC), AtomCell(UInt(3)),
            InstCell(LTE)
        ])
    )
}

#[test]
fn test_compile_string() {
    assert_eq!(
        StringNode{ value: "a string".to_string() }
            .compile(&SymTable::new()),
        Ok(vec![ListCell(box list!(
            AtomCell(Char('a')),
            AtomCell(Char(' ')),
            AtomCell(Char('s')),
            AtomCell(Char('t')),
            AtomCell(Char('r')),
            AtomCell(Char('i')),
            AtomCell(Char('n')),
            AtomCell(Char('g'))
            ))])
        )
}