rust_multistackvm 0.38.0

Stack-based virtual machine on top of rust_multistack crate
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::multistackvm::VM;
use rust_dynamic::value::Value;
use num::complex::Complex;
use easy_error::{Error, bail};

pub fn stdlib_pair_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 1 {
        bail!("Stack is too shallow for inline pair()");
    }
    let x = match vm.stack.pull() {
        Some(x) => x,
        None => {
            bail!("PAIR returns NO DATA #1");
        }
    };
    let y = match vm.stack.pull() {
        Some(y) => y,
        None => {
            bail!("PAIR returns NO DATA #2");
        }
    };
    vm.apply(Value::pair(x, y))
}

pub fn stdlib_complex_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 1 {
        bail!("Stack is too shallow for inline pair()");
    }
    let re = match vm.stack.pull() {
        Some(x) => x,
        None => {
            bail!("COMPLEX returns NO DATA #1");
        }
    };
    let im = match vm.stack.pull() {
        Some(y) => y,
        None => {
            bail!("COMPLEX returns NO DATA #2");
        }
    };
    let re_float = match re.cast_float() {
        Ok(re_float) => re_float,
        Err(err) => {
            bail!("COMPLEX cast error #1: {}", err);
        }
    };
    let im_float = match im.cast_float() {
        Ok(re_float) => re_float,
        Err(err) => {
            bail!("COMPLEX cast error #2: {}", err);
        }
    };
    let res: Complex<f64> = Complex::new(re_float, im_float);
    vm.apply(Value::from_complex_float(res))
}

pub fn stdlib_list_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::list())
}

pub fn stdlib_metrics_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::metrics())
}

pub fn stdlib_lambda_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::lambda())
}

pub fn stdlib_class_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    let mut res = Value::make_class();
    res = res.set(".super", Value::list());
    vm.apply(res)
}

pub fn stdlib_valuemap_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::valuemap())
}


pub fn stdlib_ptr_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    if vm.stack.current_stack_len() < 1 {
        bail!("Stack is too shallow for inline ptr()");
    }
    match vm.stack.pull() {
        Some(name_value) => {
            match name_value.cast_string() {
                Ok(name) => {
                    return vm.apply(Value::ptr(name.clone(), Vec::new()));
                }
                Err(err) => {
                    bail!("PTR returns error: {}", err);
                }
            }
        }
        None => {
            bail!("PTR returns: NO DATA");
        }
    }
}

pub fn stdlib_bool_true_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::from_bool(true))
}

pub fn stdlib_bool_false_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::from_bool(false))
}

pub fn stdlib_nodata_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::nodata())
}

pub fn stdlib_dict_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::dict())
}

pub fn stdlib_textbuffer_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    vm.apply(Value::text_buffer("".to_string()))
}

pub fn stdlib_conditional_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    let mut res: Value = Value::conditional();
    res = res.set("type", Value::from_string("through"));
    vm.apply(res)
}

pub fn stdlib_conditional_try_inline(vm: &mut VM) -> Result<&mut VM, Error> {
    let mut res: Value = Value::conditional();
    res = res.set("type", Value::from_string("try"));
    vm.apply(res)
}

pub fn init_stdlib(vm: &mut VM) {
    let _ = vm.register_inline("list".to_string(), stdlib_list_inline);
    let _ = vm.register_inline("lambda".to_string(), stdlib_lambda_inline);
    let _ = vm.register_inline("ptr".to_string(), stdlib_ptr_inline);
    let _ = vm.register_inline("true".to_string(), stdlib_bool_true_inline);
    let _ = vm.register_inline("false".to_string(), stdlib_bool_false_inline);
    let _ = vm.register_inline("nodata".to_string(), stdlib_nodata_inline);
    let _ = vm.register_inline("dict".to_string(), stdlib_dict_inline);
    let _ = vm.register_inline("conditional".to_string(), stdlib_conditional_inline);
    let _ = vm.register_inline("text".to_string(), stdlib_textbuffer_inline);
    let _ = vm.register_inline("pair".to_string(), stdlib_pair_inline);
    let _ = vm.register_inline("complex".to_string(), stdlib_complex_inline);
    let _ = vm.register_inline("metrics".to_string(), stdlib_metrics_inline);
    let _ = vm.register_inline("class".to_string(), stdlib_class_inline);
    let _ = vm.register_inline("valuemap".to_string(), stdlib_valuemap_inline);
}