quickscript 0.5.5

A quick programming language with a compiler implemented in Rust.
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 std::{any::Any, mem::transmute};

use anyhow::Result;
use cranelift_codegen::{
    isa::lookup,
    settings::{builder as flag_builder, Configurable, Flags},
};
use cranelift_frontend::FunctionBuilderContext;
use cranelift_module::{default_libcall_names, DataDescription, DataId, FuncId, Module};
use qsc_cranelift_jit::{JITBuilder, JITModule};
use target_lexicon::Triple;

use super::backend::CraneliftBackend;

impl CraneliftBackend<JITModule> {
    pub fn new(target: Triple, disasm: bool) -> Result<Self> {
        let mut flags = flag_builder();

        flags.set("use_colocated_libcalls", "false")?;
        flags.set("is_pic", "false")?;

        let isa = lookup(target)?.finish(Flags::new(flags))?;
        let builder = JITBuilder::with_isa(isa, default_libcall_names());
        let module = JITModule::new(builder);

        Ok(Self {
            builder_ctx: FunctionBuilderContext::new(),
            ctx: module.make_context(),
            data_desc: DataDescription::new(),
            module,
            fns: Vec::new(),
            code: Vec::new(),
            disasm,
            is_jit: true,
            bytecode: Vec::new(),
            watch_mode: false,
        })
    }

    pub fn run(&self) -> Result<i32> {
        let mut main = None;

        for (name, code, _) in self.bytecode.clone() {
            if name == "_start" {
                main = Some(code);
            }
        }

        let main = main.ok_or(anyhow!("No main function found!"))?;
        let main = unsafe { transmute::<_, fn() -> i32>(main) };

        Ok(main())
    }
}

pub trait JITFinish {
    fn jit_finish_fn(&mut self, name: String, id: FuncId) -> Result<()>;
    fn jit_finish_data(&mut self, id: DataId) -> Result<()>;
}

impl<T> JITFinish for CraneliftBackend<T>
where
    T: Module + 'static,
{
    fn jit_finish_fn(&mut self, name: String, id: FuncId) -> Result<()> {
        if self.is_jit {
            let module = &mut self.module as &mut dyn Any;
            let module = module.downcast_mut::<JITModule>().unwrap();

            module.finalize_definitions()?;

            let (code, len) = module.get_finalized_function(id);

            self.bytecode.push((name, code, len));
        }

        Ok(())
    }

    fn jit_finish_data(&mut self, id: DataId) -> Result<()> {
        if self.is_jit {
            let module = &mut self.module as &mut dyn Any;
            let module = module.downcast_mut::<JITModule>().unwrap();

            module.finalize_definitions()?;

            let (code, len) = module.get_finalized_data(id);

            self.bytecode.push((String::new(), code, len));
        }

        Ok(())
    }
}