rs2c 0.0.1

A (very WIP) Rust to C transpiler
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

//! # opencl
//! 
//! The `opencl` module is an optional module that implements transpiling Rust functions into OpenCL
//! kernel functions. 

use crate::*;

/// Transpiles a single Rust function provided in `source` into an OpenCL kernel function
pub fn rs_to_cl_kernel(source: &str) -> String {
    let cl_sig = rs_to_cl_signature(get_fn_signature(source)).unwrap();

    let expr = syn::parse_str::<Expr>(&get_fn_block(source)).unwrap();
    //println!("{:#?}", expr);
    let c_block = convert_expr(expr).to_string();

    format!("{} {}", cl_sig, c_block)
}

/// Converts a Rust function signature into an OpenCL kernel function signature
fn rs_to_cl_signature(sig: String) -> Result<String, String> {
    match sig.split("->").nth(1) {
        Some(_) => {return Err("Kernel functions can't return values.".to_string());},
        None => {},
    };
    let fn_name: String = sig.split('(').next().expect("msg").replace("fn", "").trim().to_string();
    let args: Vec<&str> = sig.split('(').nth(1).expect("msg").split(')').next().expect("msg").split(',').collect();
    let mut c_args = String::new();
    for (i, arg) in args.iter().enumerate() {
        let name = arg.split(':').next().expect("msg").trim().to_string();
        let is_const = !arg.split(':').nth(1).expect("msg").contains("mut ");
        let c_type = convert_to_c_type(&arg.split(':').nth(1).expect("msg").replace("mut ", "")).unwrap();
        let is_buffer = c_type.contains('*');
        if is_const {
            c_args += "const ";
        }
        if is_buffer {
            c_args += "global ";
        }
        if c_type.contains("arrname") {
            c_args += &c_type.replace("arrname", &name);
        } else {
            c_args += &format!("{} {}", c_type, name);
        }
        if i != args.len()-1 {
            c_args += ", ";
        }
    }
    let c_sig = format!("__kernel void {}({})", fn_name, c_args);
    Ok(c_sig)
}