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
extern crate proc_macro;
extern crate proc_macro2;
#[macro_use]
extern crate syn;
#[macro_use]
extern crate quote;
use proc_macro::TokenStream;
mod derive_conv_variant;
mod derive_macro;
mod method_macro;
#[proc_macro_attribute]
pub fn methods(meta: TokenStream, input: TokenStream) -> TokenStream {
let (impl_block, export) = method_macro::parse_method_export(meta, input);
let output = {
let class_name = export.class_ty;
let methods = export
.methods
.into_iter()
.map(|m| {
let name = m.ident.clone().to_string();
quote!(
{
let method = gdnative::godot_wrap_method!(
#class_name,
#m
);
builder.add_method(#name, method);
}
)
})
.collect::<Vec<_>>();
quote::quote!(
#impl_block
impl gdnative::NativeClassMethods for #class_name {
fn register(builder: &gdnative::init::ClassBuilder<Self>) {
use gdnative::init::*;
#(#methods)*
}
}
)
};
TokenStream::from(output)
}
#[proc_macro_derive(NativeClass, attributes(inherit, export, user_data))]
pub fn derive_native_class(input: TokenStream) -> TokenStream {
let data = derive_macro::parse_derive_input(input.clone());
let trait_impl = {
let name = data.name;
let base = data.base;
let user_data = data.user_data;
let name_str = quote!(#name).to_string();
quote!(
impl gdnative::NativeClass for #name {
type Base = #base;
type UserData = #user_data;
fn class_name() -> &'static str {
#name_str
}
fn init(owner: Self::Base) -> Self {
Self::_init(owner)
}
}
)
};
trait_impl.into()
}
#[proc_macro_derive(ToVariant)]
pub fn derive_to_variant(input: TokenStream) -> TokenStream {
derive_conv_variant::derive_to_variant(input)
}
#[proc_macro_derive(FromVariant)]
pub fn derive_from_variant(input: TokenStream) -> TokenStream {
derive_conv_variant::derive_from_variant(input)
}