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

#![feature(extern_crate_item_prelude)]
#![feature(concat_idents)]
#![recursion_limit = "128"]

// Rust std crate must be imported like this
extern crate proc_macro;

use quote::quote;
use syn::spanned::Spanned;

#[proc_macro_attribute]
pub fn epics_register(
    _attr: proc_macro::TokenStream,
    item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let ast = syn::parse(item).unwrap();

    impl_epics_register(&ast).into()
}

fn impl_epics_register(ast: &syn::ItemFn) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let name_str = name.to_string();
    if !name_str.ends_with("_impl") {
        return syn::parse::Error::new(name.span(), "expected name to end with `_impl`")
            .to_compile_error();
    }
    let name2 = syn::Ident::new(name_str.trim_end_matches(&"_impl"), name.span());

    if ast.decl.inputs.len() != 1 {
        return syn::parse::Error::new(
            ast.decl.paren_token.span,
            "expected function to have 1 argument",
        )
        .to_compile_error();
    }
    let rec_type = &ast.decl.inputs.first().unwrap().into_value();
    let rec_type = match rec_type {
        syn::FnArg::Captured(arg) => Some(&arg.ty),
        _ => {
            return syn::parse::Error::new(rec_type.span(), "unknown argument").to_compile_error();
        }
    }
    .unwrap();
    let rec_type = match rec_type {
        syn::Type::Reference(ty) => Some(ty.elem.as_ref()),
        _ => {
            return syn::parse::Error::new(rec_type.span(), "expected reference").to_compile_error();
        }
    }
    .unwrap();
    let rec_type = match rec_type {
        syn::Type::Path(ty) => Some(ty),
        _ => {
            return syn::parse::Error::new(rec_type.span(), "expected path/type").to_compile_error();
        }
    }
    .unwrap();
    //println!("{:#?}", rec_type);

    let gen = quote! {
        paste::item! {
            #[no_mangle]
            pub extern "C" fn #name2(precord: *mut #rec_type) -> ::std::os::raw::c_long {
                match #name(unsafe {&mut *precord}) {
                    Ok(()) => 0,
                    Err(()) => 1,
                }
            }

            #[no_mangle]
            pub fn [<register_func_ #name2>]() {
                use std::mem;
                let fnname = format!("{}\0", stringify!(#name2));
                unsafe {
                    registryFunctionAdd(
                        fnname.as_ptr() as *const _,
                        Some(mem::transmute::<extern "C" fn(*mut #rec_type) -> ::std::os::raw::c_long, unsafe extern "C" fn()>(#name2)));
                }
            }

            #[no_mangle]
            pub static mut [<pvar_func_register_func_ #name2>]: *const ::std::os::raw::c_void = [<register_func_ #name2>] as *const ::std::os::raw::c_void;

        }

        #ast
    };
    gen.into()
}