onion-frontend 0.2.2

Compilation frontend for the Onion programming language - lexer, parser, and IR generator
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

use crate::dir_stack::DirectoryStack;
use crate::ir_generator::ir_generator;
use crate::parser::analyzer::analyze_ast;
use crate::parser::analyzer::auto_capture_and_rebuild;
use crate::parser::analyzer::expand_macro;
use crate::parser::ast::ast_token_stream;
use crate::parser::ast::build_ast;
use crate::parser::lexer::lexer;
use crate::utils::cycle_detector::CycleDetector;
use colored::Colorize;
use onion_vm::types::lambda::vm_instructions::instruction_set::VMInstructionPackage;
use onion_vm::types::lambda::vm_instructions::ir::DebugInfo;
use onion_vm::types::lambda::vm_instructions::ir::Functions;
use onion_vm::types::lambda::vm_instructions::ir::IRPackage;
use onion_vm::types::lambda::vm_instructions::ir::IR;
use onion_vm::types::lambda::vm_instructions::ir_translator::IRTranslator;

// Compile code and generate intermediate representation
pub fn build_code(
    code: &str,
    cycle_detector: &mut CycleDetector<String>,
    dir_stack: &mut DirectoryStack,
) -> Result<IRPackage, String> {
    let tokens = lexer::tokenize(code);
    let tokens = lexer::reject_comment(&tokens);
    let gathered = ast_token_stream::from_stream(&tokens);
    let ast = match build_ast(gathered) {
        Ok(ast) => ast,
        Err(err_token) => {
            return Err(err_token.format().to_string());
        }
    };
    let macro_result = expand_macro(&ast, cycle_detector, dir_stack);

    let mut errors = "".to_string();
    for error in &macro_result.errors {
        //println!("{}", error.format(code.to_string()).bright_red());
        errors.push_str(&error.format());
        errors.push_str("\n");
    }
    if !macro_result.errors.is_empty() {
        return Err(format!("{}AST analysis failed", errors));
    }
    for warn in &macro_result.warnings {
        println!("{}", warn.format().bright_yellow());
    }

    let ast = auto_capture_and_rebuild(&macro_result.result_node).1;

    let analyse_result = analyze_ast(&ast, None, cycle_detector, dir_stack);

    let mut errors = "".to_string();
    for error in &analyse_result.errors {
        //println!("{}", error.format(code.to_string()).bright_red());
        errors.push_str(&error.format());
        errors.push_str("\n");
    }
    if !analyse_result.errors.is_empty() {
        return Err(format!("{}AST analysis failed", errors));
    }
    for warn in &analyse_result.warnings {
        println!("{}", warn.format().bright_yellow());
    }

    let namespace = ir_generator::NameSpace::new("Main".to_string(), None);
    let mut functions = Functions::new();
    let mut ir_generator = ir_generator::IRGenerator::new(&mut functions, namespace);

    let ir = match ir_generator.generate(&ast) {
        Ok(ir) => ir,
        Err(err) => {
            return Err(format!("Error: {:?}", err));
        }
    };

    let mut ir = ir;
    ir.push((DebugInfo::new((0, 0)), IR::Return));
    functions.append("__main__".to_string(), ir);

    Ok(functions.build_instructions(Some(code.to_string())))
}

// Compile IR to bytecode
pub fn compile_to_bytecode(package: &IRPackage) -> Result<VMInstructionPackage, String> {
    let mut translator = IRTranslator::new(package);
    match translator.translate() {
        Ok(_) => Ok(translator.get_result()),
        Err(e) => Err(format!("IR translation failed: {:?}", e)),
    }
}