evalit 0.2.0-beta.0

a toy interpreter
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

use crate::compiler::Compiler;
use crate::runtime::{Environment, VM};
use crate::{Error, Object, RuntimeError, Value};

#[cfg(feature = "async")]
pub fn eval<T: Object + 'static>(script: &str, env: Environment) -> Result<Option<T>, Error> {
    let compiler = Compiler::new();
    let module = compiler.compile(script, &env)?;

    let mut vm = VM::new(module, env);

    let ret = futures::executor::block_on(async { vm.run().await })?;

    match ret {
        Some(v) => {
            let v = v.take();
            v.into_inner::<T>()
                .map(|v| Some(v))
                .map_err(|err| RuntimeError::invalid_type::<T>(err).into())
        }
        None => Ok(None),
    }
}

#[cfg(feature = "async")]
pub async fn eval_async<T: Object + 'static>(
    script: &str,
    env: Environment,
) -> Result<Option<T>, Error> {
    let compiler = Compiler::new();
    let module = compiler.compile(script, &env)?;

    let mut vm = VM::new(module, env);

    let ret = vm.run().await?;

    match ret {
        Some(v) => {
            let v = v.take();
            v.into_inner::<T>()
                .map(|v| Some(v))
                .map_err(|err| RuntimeError::invalid_type::<T>(err).into())
        }
        None => Ok(None),
    }
}

#[cfg(not(feature = "async"))]
pub fn eval<T: Object + 'static>(script: &str, env: Environment) -> Result<Option<T>, Error> {
    let compiler = Compiler::new();
    let module = compiler.compile(script, &env)?;

    let mut vm = VM::new(module, env);

    let ret = vm.run()?;

    match ret {
        Some(v) => {
            let v = v.take();
            v.into_inner::<T>()
                .map(|v| Some(v))
                .map_err(|err| RuntimeError::invalid_type::<T>(err).into())
        }
        None => Ok(None),
    }
}

pub struct Interpreter {}

impl Interpreter {
    #[cfg(feature = "async")]
    pub fn eval(script: &str, env: Environment) -> Result<Option<Value>, Error> {
        let compiler = Compiler::new();
        let module = compiler.compile(script, &env)?;

        let mut vm = VM::new(module, env);

        let ret = futures::executor::block_on(async { vm.run().await })?;

        Ok(ret.map(|v| v.take()))
    }

    #[cfg(not(feature = "async"))]
    pub fn eval(script: &str, env: Environment) -> Result<Option<Value>, Error> {
        let compiler = Compiler::new();
        let module = compiler.compile(script, &env)?;

        let mut vm = VM::new(module, env);

        let ret = vm.run()?;

        Ok(ret.map(|v| v.take()))
    }
}