Skip to content
Snippets Groups Projects
Select Git revision
  • f76bdc285d70e1fe674843a6e329ae7707fdaa49
  • master default protected
  • exam
  • exper
  • klee
  • simple
  • v0.3.2
  • v0.3.1
  • v0.3.0
  • v0.2.2
  • v0.2.1
  • v0.2.0
  • v0.1.1
  • v0.1.0
14 results

full-syntax.rs

Blame
  • crust.rs 23.43 KiB
    use crust::{
        ast::{Block, Cmd, Expr, Func, Op, Span, SpanExpr},
        parse::{parse_block, parse_expr},
    };
    
    use inkwell::{
        builder::Builder,
        context::Context,
        execution_engine::{ExecutionEngine, JitFunction},
        module::Module,
        passes::PassManager,
        types::BasicTypeEnum,
        values::{
            BasicValueEnum, FloatValue, FunctionValue, InstructionValue, IntValue,
            PointerValue,
        },
        FloatPredicate, OptimizationLevel,
    };
    use std::collections::HashMap;
    use std::error::Error;
    
    type ExprFunc = unsafe extern "C" fn() -> i32;
    
    fn main() -> Result<(), Box<dyn Error>> {
        let context = Context::create();
        let mut module = context.create_module("expr");
        let builder = context.create_builder();
        let fpm = PassManager::create(&module);
        fpm.initialize();
        let execution_engine =
            module.create_jit_execution_engine(OptimizationLevel::None)?;
    
        match parse_block(Span::new(
            "
            {
                return  2 + 3
            }
            ",
        )) {
            Ok((_, prog)) => {
                println!("{:?}", &prog);
                let u32_type = context.i32_type();
                let fn_type = u32_type.fn_type(&[], false);
                let function = module.add_function("expr", fn_type, None);
                let basic_block = context.append_basic_block(&function, "entry");
                builder.position_at_end(&basic_block);
    
                let mut compiler = Compiler {
                    context: &context,
                    builder: &builder,
                    module: &module,
                    fn_value_opt: Some(function),
                    //&fpm,
                };
                let res = compiler.compile_block(prog);
                // builder.build_return(Some(&res));
                let fun_expr: JitFunction<ExprFunc> =
                    unsafe { execution_engine.get_function("expr").ok().unwrap() };
    
                unsafe {
                    println!("{}", fun_expr.call());
                }
            }
            _ => panic!(),
        }
        println!("module: {}", module.print_to_string());
    
        Ok(())
    }