ellie_engine 1.5.20-alpha

Why ellie? Ellie is a type-safe programing language that runs on embedded and sandboxed environments.
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

use alloc::vec::Vec;
use ellie_bytecode::assembler::{self, AssembleResult, PlatformAttributes};
use ellie_core::defs::ModuleMap;
use ellie_parser::utils::Module;

/// Transpile parsed code
/// ## Parameters
/// * `module` - Module to transpile [`Module`]
/// * `platform_attributes` - Platform attributes [`PlatformAttributes`]
/// * * `module_maps` - Module maps [`Vec<ModuleMap>`]
/// ## Returns
/// [`AssembleResult`] of transpiled code
pub fn transpile_parsed_code(
    module: Module,
    platform_attributes: PlatformAttributes,
    module_maps: Vec<ModuleMap>,
) -> AssembleResult {
    let mut assembler = assembler::Assembler::new(module, platform_attributes);
    assembler.assemble(module_maps)
}

/// Transpile given text macro
/// ## Parameters
/// * `text` - Text to transpile [`&str`]
/// * `platform_attributes` - Platform attributes [`PlatformAttributes`]
/// * * `module_maps` - Module maps [`Vec<ModuleMap>`]
/// ## Returns
/// [`AssembleResult`] of transpiled code
/// ## Example
/// ```rust
/// use ellie_engine::byteCode;
/// let text = r#"\
/// fn main() {
///    print("Hello, World!");
/// }
/// "#;
/// let result = byteCode::transpileText!(text, PlatformAttributes::default(), vec![]);
/// ```
#[macro_export]
macro_rules! transpileText {
    ($text:expr, $platform_attributes:expr, $module_maps:expr) => {{
        use ellie_engine::{
            ellie_bytecode::assembler, ellie_core::defs::ModuleMap, ellie_parser::utils::Module,
        };

        let text = $text;
        let module = ellie_parser::parseText!(text);
        let result = ellie_engine::byteCode::transpile_parsed_code(
            module,
            $platform_attributes,
            $module_maps,
        );
        result
    }};
}