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
95
96
97
98
99
100
101
102
103
extern crate proc_macro;
use proc_macro::{TokenStream, TokenTree};
use quote::quote;
use syn::{parse_macro_input, DeriveInput};
use quote::ToTokens;
#[proc_macro_attribute]
pub fn qan_export(args: TokenStream, input: TokenStream) -> TokenStream {
let mut boilerplate = format!(r#"
#[no_mangle]
{}
"#, input);
let parsed_fn: syn::ItemFn = parse_macro_input!(input);
let mut should_wrap = false;
let items: Vec<&syn::FnArg> = parsed_fn.sig.inputs.iter().collect();
if items.len() > 0 {
boilerplate += "\n#[derive(Serialize, Deserialize)]";
boilerplate += format!("\npub struct _{}_wrapped%lifetime% {{", parsed_fn.sig.ident).as_ref();
}
for input in &items {
match input {
syn::FnArg::Typed(p) => {
let pat_id = *p.pat.clone();
let param_name = match pat_id {
syn::Pat::Ident(t) => t.ident,
_ => continue
};
let pat_ty = *p.ty.clone();
let param_type = match pat_ty {
syn::Type::Path(t) => {
let param_type = &t.path.segments[t.path.segments.len()-1].ident;
should_wrap = match param_type.to_string().as_ref() {
"i32" => false,
"i64" => false,
"f32" => false,
"f64" => false,
"String" => true,
"Address" => false,
"DateTime" => false,
"Customer" => true,
_ => false
};
boilerplate += format!("\n{}: {}", param_name, param_type).as_ref();
if should_wrap {
boilerplate = boilerplate.replace("%lifetime%", "");
boilerplate += "";
}
boilerplate += ",";
},
_ => continue
};
},
_ => {}
}
}
boilerplate = boilerplate.replace("%lifetime%", "");
if items.len() > 0 {
boilerplate += "\n}\n";
}
if should_wrap {
let mut ret_type = String::new();
boilerplate += format!("#[no_mangle]\npub fn _{}(len: i32) -> Vec<u8>",
parsed_fn.sig.ident).as_ref();
match parsed_fn.sig.output {
syn::ReturnType::Default => {},
syn::ReturnType::Type(_, bt) => {
match *bt {
syn::Type::Path(t) => {
ret_type = t.path.segments[t.path.segments.len()-1].ident.to_string();
},
_ => {}
}
}
}
boilerplate += format!("{{
let p = 0 as *mut u8;
let mut buf = std::ptr::slice_from_raw_parts(p, len as usize);
let t: _{}_wrapped = unsafe {{ serde_cbor::from_slice(&*buf).unwrap() }};
let r = {} (", parsed_fn.sig.ident, parsed_fn.sig.ident).as_ref();
for input in &items {
match input {
syn::FnArg::Typed(p) => {
let pat_id = *p.pat.clone();
let param_name = match pat_id {
syn::Pat::Ident(t) => t.ident,
_ => continue
};
boilerplate += format!("t.{},", param_name.to_string()).as_ref();
},
_ => {}
}
}
boilerplate += ");\n";
boilerplate += "serde_cbor::to_vec(&r).unwrap()\n}"
}
println!("{}", boilerplate);
boilerplate.parse().expect("Invalid tokens in macro expansion")
}