Skip to main content

jni_macros/
lib.rs

1mod bind_java_type;
2mod mangle;
3mod native_method;
4mod signature;
5mod str;
6mod types;
7mod utils;
8
9// Note: This crate is marked with doctest = false and documentation is owned
10// by the jni crate. See ../../jni/docs/macros/jni_str.md file
11#[proc_macro]
12pub fn jni_str(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
13    str::jni_str_impl(input.into())
14        .unwrap_or_else(|e| e.to_compile_error())
15        .into()
16}
17
18/// Converts UTF-8 string literals to a MUTF-8 encoded CStr literal.
19///
20/// This macro is equivalent to [`jni_str!`] but returns a `&CStr` instead of a `&'static JNIStr`.
21///
22/// See the [`jni_str!`] macro documentation for detailed syntax and examples.
23#[proc_macro]
24pub fn jni_cstr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
25    str::jni_cstr_impl(input.into())
26        .unwrap_or_else(|e| e.to_compile_error())
27        .into()
28}
29
30// Note: This crate is marked with doctest = false and documentation is owned
31// by the jni crate. See ../../jni/docs/macros/jni_sig.md file
32#[proc_macro]
33pub fn jni_sig(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
34    signature::jni_sig_impl(input.into())
35        .unwrap_or_else(|e| e.to_compile_error())
36        .into()
37}
38
39/// Parses a JNI method or field signature at compile time and returns a `&str` literal.
40///
41/// This macro is similar to `jni_sig!` but returns a plain UTF-8 string literal instead
42/// of a `MethodSignature` or `FieldSignature` struct.
43///
44/// See the `jni_sig!` macro documentation for detailed syntax and examples.
45///
46/// # Examples
47///
48/// ```ignore
49/// const SIG: &str = jni_sig_str!((a: jint, b: jboolean) -> void);
50/// // Result: "(IZ)V"
51///
52/// const FIELD_SIG: &str = jni_sig_str!(java.lang.String);
53/// // Result: "Ljava/lang/String;"
54/// ```
55#[proc_macro]
56pub fn jni_sig_str(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
57    signature::jni_sig_str_impl(input.into())
58        .unwrap_or_else(|e| e.to_compile_error())
59        .into()
60}
61
62/// Parses a JNI method or field signature at compile time and returns a CStr literal.
63///
64/// This macro is similar to `jni_sig!` but returns a C string literal (e.g., `c"(IZ)V"`)
65/// with MUTF-8 encoding instead of a `MethodSignature` or `FieldSignature` struct.
66///
67/// The output is encoded using Java's modified UTF-8 (MUTF-8) format via `simd_cesu8::mutf8::encode`.
68///
69/// See the `jni_sig!` macro documentation for detailed syntax and examples.
70///
71/// # Examples
72///
73/// ```ignore
74/// const SIG: &CStr = jni_sig_cstr!((a: jint, b: jboolean) -> void);
75/// // Result: c"(IZ)V" (MUTF-8 encoded)
76///
77/// const FIELD_SIG: &CStr = jni_sig_cstr!(java.lang.String);
78/// // Result: c"Ljava/lang/String;" (MUTF-8 encoded)
79/// ```
80#[proc_macro]
81pub fn jni_sig_cstr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
82    signature::jni_sig_cstr_impl(input.into())
83        .unwrap_or_else(|e| e.to_compile_error())
84        .into()
85}
86
87/// Parses a JNI method or field signature at compile time and returns a `&'static JNIStr`.
88///
89/// This macro is similar to `jni_sig!` but returns a `&'static JNIStr` with MUTF-8 encoding
90/// instead of a `MethodSignature` or `FieldSignature` struct.
91///
92/// The output is encoded using Java's modified UTF-8 (MUTF-8) format via `simd_cesu8::mutf8::encode`
93/// and wrapped in a `JNIStr` via `jni::strings::JNIStr::from_cstr_unchecked()`.
94///
95/// See the `jni_sig!` macro documentation for detailed syntax and examples.
96///
97/// # Examples
98///
99/// ```ignore
100/// const SIG: &JNIStr = jni_sig_jstr!((a: jint, b: jboolean) -> void);
101/// // Result: &'static JNIStr for "(IZ)V" (MUTF-8 encoded)
102///
103/// const FIELD_SIG: &JNIStr = jni_sig_jstr!(java.lang.String);
104/// // Result: &'static JNIStr for "Ljava/lang/String;" (MUTF-8 encoded)
105/// ```
106#[proc_macro]
107pub fn jni_sig_jstr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
108    signature::jni_sig_jstr_impl(input.into())
109        .unwrap_or_else(|e| e.to_compile_error())
110        .into()
111}
112
113// Note: This crate is marked with doctest = false and documentation is owned
114// by the jni crate. See ../../jni/docs/macros/jni_mangle.md file
115#[proc_macro_attribute]
116pub fn jni_mangle(
117    attr: proc_macro::TokenStream,
118    item: proc_macro::TokenStream,
119) -> proc_macro::TokenStream {
120    mangle::jni_mangle2(attr.into(), item.into()).into()
121}
122
123// Note: This crate is marked with doctest = false and documentation is owned
124// by the jni crate. See ../../jni/docs/macros/native_method.md file
125#[proc_macro]
126pub fn native_method(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
127    native_method::native_method_impl(input.into())
128        .unwrap_or_else(|e| e.to_compile_error())
129        .into()
130}
131
132// Note: This crate is marked with doctest = false and documentation is owned
133// by the jni crate. See ../../jni/docs/macros/bind_java_type_*.md files
134#[proc_macro]
135pub fn bind_java_type(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
136    bind_java_type::bind_java_type_impl(input.into())
137        .unwrap_or_else(|e| e.to_compile_error())
138        .into()
139}