chore: refactored macro a bit

This commit is contained in:
əlemi 2024-09-21 20:14:51 +02:00
parent 4d511bbcb3
commit 8f272bd905
Signed by: alemi
GPG key ID: A4895B84D311642C
5 changed files with 252 additions and 6 deletions

10
Cargo.lock generated
View file

@ -54,15 +54,15 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
[[package]]
name = "jni-toolbox"
version = "0.1.1"
version = "0.1.2"
dependencies = [
"jni",
"jni-toolbox-macro 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"jni-toolbox-macro 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "jni-toolbox-macro"
version = "0.1.1"
version = "0.1.2"
dependencies = [
"proc-macro2",
"quote",
@ -71,9 +71,9 @@ dependencies = [
[[package]]
name = "jni-toolbox-macro"
version = "0.1.1"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac89a7b1059ecda1171ee751e153c5b00722cbce7a12781a664489155af8112b"
checksum = "745ca1133357c564fec2b82d0bbe2c9b537b952ac2525667802c298015eaa494"
dependencies = [
"proc-macro2",
"quote",

View file

@ -11,7 +11,6 @@ edition = "2021"
[lib]
proc-macro = true
path = "macro.rs"
[dependencies]
syn = {version = "2.0", features = ["full"]}

72
macro/src/attrs.rs Normal file
View file

@ -0,0 +1,72 @@
use proc_macro2::{Span, TokenStream, TokenTree};
pub(crate) struct AttrsOptions {
pub(crate) package: String,
pub(crate) class: String,
pub(crate) exception: Option<String>,
pub(crate) return_pointer: bool,
pub(crate) without_env: bool,
pub(crate) without_class: bool,
}
impl AttrsOptions {
pub(crate) fn parse_attr(attrs: TokenStream) -> Result<Self, syn::Error> {
let mut what_next = WhatNext::Nothing;
let mut package = None;
let mut class = None;
let mut exception = None;
let mut return_pointer = false;
let mut without_env = false;
let mut without_class = false;
for attr in attrs {
match what_next {
WhatNext::Nothing => {
if let TokenTree::Ident(ref i) = attr {
match i.to_string().as_ref() {
"package" => what_next = WhatNext::Package,
"class" => what_next = WhatNext::Class,
"exception" => what_next = WhatNext::Exception,
"ptr" => return_pointer = true,
"no_env" => without_env = true,
"no_class" => without_class = true,
_ => return Err(syn::Error::new(Span::call_site(), "unexpected attribute on macro: {attr}")),
}
}
},
WhatNext::Class => {
if let TokenTree::Literal(i) = attr {
class = Some(i.to_string().replace('"', ""));
what_next = WhatNext::Nothing;
}
},
WhatNext::Package => {
if let TokenTree::Literal(i) = attr {
package = Some(i.to_string().replace('"', "").replace(".", "_"));
what_next = WhatNext::Nothing;
}
},
WhatNext::Exception => {
if let TokenTree::Literal(i) = attr {
exception = Some(i.to_string().replace('"', "").replace(".", "_"));
what_next = WhatNext::Nothing;
}
}
}
}
let Some(package) = package else { return Err(syn::Error::new(Span::call_site(), "missing required attribute 'package'")) };
let Some(class) = class else { return Err(syn::Error::new(Span::call_site(), "missing required attribute 'class'")) };
Ok(Self { package, class, exception, return_pointer, without_class, without_env })
}
}
enum WhatNext {
Nothing,
Package,
Class,
Exception,
}

17
macro/src/lib.rs Normal file
View file

@ -0,0 +1,17 @@
mod attrs;
mod wrapper;
/// wrap this function in in a JNI exported fn
#[proc_macro_attribute]
pub fn jni(
attrs: proc_macro::TokenStream,
input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
wrapper::generate_jni_wrapper(
syn::parse_macro_input!(attrs),
syn::parse_macro_input!(input),
)
.unwrap()
.into()
}

158
macro/src/wrapper.rs Normal file
View file

@ -0,0 +1,158 @@
use proc_macro2::{Span, TokenStream};
use quote::TokenStreamExt;
use syn::{FnArg, Item, ReturnType, Type};
use crate::attrs::AttrsOptions;
pub(crate) fn generate_jni_wrapper(attrs: TokenStream, input: TokenStream) -> Result<TokenStream, syn::Error> {
let mut out = TokenStream::new();
let Item::Fn(fn_item) = syn::parse2(input.clone())? else {
return Err(syn::Error::new(Span::call_site(), "#[jni] is only supported on functions"));
};
let attrs = AttrsOptions::parse_attr(attrs)?;
let (could_error, ret_type) = match fn_item.sig.output {
syn::ReturnType::Default => (false, fn_item.sig.output),
syn::ReturnType::Type(_tok, ty) => match *ty {
syn::Type::Path(ref path) => {
let Some(last) = path.path.segments.last() else {
return Err(syn::Error::new(Span::call_site(), "empty Result type is not valid"));
};
// TODO this is terrible, macro returns a function and we call it?? there must be a
// better way!!!
let mut out = (
false,
ReturnType::Type(syn::Token![->](Span::call_site()), Box::new(Type::Path(path.clone())))
);
if last.ident == "Result" {
match &last.arguments {
syn::PathArguments::None => return Err(syn::Error::new(Span::call_site(), "Result without generics is not valid")),
syn::PathArguments::Parenthesized(_) => return Err(syn::Error::new(Span::call_site(), "Parenthesized Result is not valid")),
syn::PathArguments::AngleBracketed(ref generics) => for generic in generics.args.iter() {
match generic {
syn::GenericArgument::Lifetime(_) => continue,
syn::GenericArgument::Type(ty) => {
out = (true, ReturnType::Type(syn::Token![->](Span::call_site()), Box::new(ty.clone())));
break;
},
_ => return Err(syn::Error::new(Span::call_site(), "unexpected type in Result")),
}
}
}
}
out
},
_ => return Err(syn::Error::new(Span::call_site(), "unsupported return type")),
},
};
let mut incoming = TokenStream::new();
let mut forwarding = TokenStream::new();
for arg in fn_item.sig.inputs {
let FnArg::Typed(ty) = arg else {
return Err(syn::Error::new(Span::call_site(), "#[jni] macro doesn't work on methods"));
};
incoming.append_all(quote::quote!( #ty , ));
let pat = unpack_pat(*ty.pat)?;
forwarding.append_all(pat);
}
let name = fn_item.sig.ident.to_string();
let name_jni = name.replace("_", "_1");
let fn_name_inner = syn::Ident::new(&name, Span::call_site());
let fn_name = syn::Ident::new(&format!("Java_{}_{}_{name_jni}", attrs.package, attrs.class), Span::call_site());
let Some(env_ident) = forwarding.clone().into_iter().next() else {
return Err(syn::Error::new(Span::call_site(), "missing JNIEnv argument"));
};
let return_expr = if attrs.return_pointer {
quote::quote!( std::ptr::null_mut() )
} else {
quote::quote!( 0 )
};
let wrapped = if could_error {
if let Some(exception) = attrs.exception {
// V----------------------------------V
quote::quote! {
#[no_mangle]
#[allow(unused_mut)]
pub extern "system" fn #fn_name<'local>(#incoming) #ret_type {
use jni_toolbox::JniToolboxError;
match #fn_name_inner(#forwarding) {
Ok(ret) => ret,
Err(e) => match #env_ident.throw_new(#exception, format!("{e:?}")) {
Ok(_) => return #return_expr,
Err(e) => panic!("error throwing java exception: {e}"),
}
}
}
}
// ^----------------------------------^
} else {
// V----------------------------------V
quote::quote! {
#[no_mangle]
#[allow(unused_mut)]
pub extern "system" fn #fn_name<'local>(#incoming) #ret_type {
use jni_toolbox::JniToolboxError;
// NOTE: this is SAFE! the cloned env reference lives less than the actual one, we just lack a
// way to get it back from the called function and thus resort to unsafe cloning
let mut env_copy = unsafe { #env_ident.unsafe_clone() };
match #fn_name_inner(#forwarding) {
Err(e) => match env_copy.find_class(e.jclass()) {
Err(e) => panic!("error throwing Java exception -- failed resolving error class: {e}"),
Ok(class) => match env_copy.new_string(format!("{e:?}")) {
Err(e) => panic!("error throwing Java exception -- failed creating error string: {e}"),
Ok(msg) => match env_copy.new_object(class, "(Ljava/lang/String;)V", &[jni::objects::JValueGen::Object(&msg)]) {
Err(e) => panic!("error throwing Java exception -- failed creating object: {e}"),
Ok(obj) => match env_copy.throw(jni::objects::JThrowable::from(obj)) {
Err(e) => panic!("error throwing Java exception -- failed throwing: {e}"),
Ok(_) => return #return_expr,
},
},
},
}
Ok(ret) => ret,
}
}
}
// ^----------------------------------^
}
} else {
// V----------------------------------V
quote::quote! {
#[no_mangle]
#[allow(unused_mut)]
pub extern "system" fn #fn_name<'local>(#incoming) #ret_type {
#fn_name_inner(#forwarding)
}
}
// ^----------------------------------^
};
out.append_all(input);
out.append_all(wrapped);
Ok(out)
}
fn unpack_pat(pat: syn::Pat) -> Result<TokenStream, syn::Error> {
match pat {
syn::Pat::Ident(i) => {
let ident = i.ident;
Ok(quote::quote!( #ident ,))
},
syn::Pat::Reference(r) => {
unpack_pat(*r.pat)
},
_ => Err(syn::Error::new(Span::call_site(), "unsupported argument type")),
}
}