pd-vm 0.22.2

RustScript bytecode compiler and VM
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
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

use std::path::Path;

use vm::{Value, Vm, VmStatus, compile_source_file};

fn run_rustscript_spec(path: &Path) -> Vec<Value> {
    let compiled = compile_source_file(path).expect("spec should compile");
    assert!(
        compiled.functions.is_empty(),
        "stdlib RustScript specs should not require host imports"
    );
    assert!(
        compiled.program.imports.is_empty(),
        "stdlib RustScript specs should not emit host imports for builtins"
    );

    let mut vm = Vm::new(compiled.program);
    loop {
        let status = vm.run().expect("spec vm should run");
        match status {
            VmStatus::Halted => break,
            VmStatus::Yielded => continue,
            VmStatus::Waiting(_op_id) => vm
                .wait_for_host_op_blocking()
                .expect("spec vm should complete builtin async op"),
        }
    }
    vm.stack().to_vec()
}

#[test]
fn stdlib_strings_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/strings.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_bytes_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/bytes.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_io_primitives_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/io_primitives.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_collections_primitives_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/collections_primitives.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_collections_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/collections.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_iter_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/iter.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_io_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/io.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_path_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/path.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_math_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/math.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_parse_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/parse.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_re_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/re.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}

#[test]
fn stdlib_lrucache_spec_passes() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
    let path = root.join("stdlib/tests/lrucache.rss");
    let stack = run_rustscript_spec(&path);
    assert_eq!(stack, Vec::<Value>::new());
}