repo clean up
This commit is contained in:
Timur Gordon
360
_archive/rhai_client_macros/src/lib.rs
Normal file
360
_archive/rhai_client_macros/src/lib.rs
Normal file
@@ -0,0 +1,360 @@
|
||||
use proc_macro::TokenStream;
|
||||
use quote::{format_ident, quote};
|
||||
use syn::{parse_macro_input, parse_quote, FnArg, ItemFn, Pat, PatType, ReturnType};
|
||||
|
||||
/// Procedural macro that generates a Rhai client function for a Rust function.
|
||||
///
|
||||
/// When applied to a Rust function, it generates a corresponding function with a '_rhai_client' suffix
|
||||
/// that calls the original function through the Rhai engine.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// #[rhai]
|
||||
/// fn hello(name: String) -> String {
|
||||
/// format!("Hello, {}!", name)
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// This will generate:
|
||||
///
|
||||
/// ```rust
|
||||
/// fn hello_rhai_client(engine: &rhai::Engine, name: String) -> String {
|
||||
/// let script = format!("hello(\"{}\")", name.replace("\"", "\\\""));
|
||||
/// engine.eval::<String>(&script).unwrap_or_else(|err| {
|
||||
/// eprintln!("Rhai script error: {}", err);
|
||||
/// String::new()
|
||||
/// })
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Note: The macro handles type conversions between Rust and Rhai types,
|
||||
/// particularly for integer types (Rhai uses i64 internally).
|
||||
#[proc_macro_attribute]
|
||||
pub fn rhai(_attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
// Parse the input function
|
||||
let input_fn = parse_macro_input!(item as ItemFn);
|
||||
let fn_name = &input_fn.sig.ident;
|
||||
let fn_name_str = fn_name.to_string();
|
||||
|
||||
// Create the client function name (original + _rhai_client)
|
||||
let client_fn_name = format_ident!("{}_rhai_client", fn_name);
|
||||
|
||||
// Extract function parameters
|
||||
let mut param_names = Vec::new();
|
||||
let mut param_types = Vec::new();
|
||||
let mut param_declarations = Vec::new();
|
||||
|
||||
for arg in &input_fn.sig.inputs {
|
||||
match arg {
|
||||
FnArg::Typed(PatType { pat, ty, .. }) => {
|
||||
if let Pat::Ident(pat_ident) = &**pat {
|
||||
let param_name = &pat_ident.ident;
|
||||
param_names.push(param_name.clone());
|
||||
param_types.push(ty.clone());
|
||||
param_declarations.push(quote! { #param_name: #ty });
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// Skip self parameters
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Determine return type
|
||||
let return_type = match &input_fn.sig.output {
|
||||
ReturnType::Default => parse_quote!(()),
|
||||
ReturnType::Type(_, ty) => ty.clone(),
|
||||
};
|
||||
|
||||
// Generate parameter formatting for the Rhai script
|
||||
let param_format_strings = param_names
|
||||
.iter()
|
||||
.zip(param_types.iter())
|
||||
.map(|(name, ty)| {
|
||||
let type_str = quote! { #ty }.to_string();
|
||||
|
||||
// Handle different parameter types
|
||||
if type_str.contains("String") {
|
||||
quote! {
|
||||
format!("\"{}\"" , #name.replace("\"", "\\\""))
|
||||
}
|
||||
} else if type_str.contains("bool") {
|
||||
quote! {
|
||||
format!("{}", #name)
|
||||
}
|
||||
} else if type_str.contains("i32") || type_str.contains("u32") {
|
||||
// Convert smaller integer types to i64 for Rhai
|
||||
quote! {
|
||||
format!("{}", #name as i64)
|
||||
}
|
||||
} else if type_str.contains("i64")
|
||||
|| type_str.contains("u64")
|
||||
|| type_str.contains("f32")
|
||||
|| type_str.contains("f64")
|
||||
{
|
||||
// Other numeric types
|
||||
quote! {
|
||||
format!("{}", #name)
|
||||
}
|
||||
} else {
|
||||
// For complex types, just pass the variable name
|
||||
// The Rhai engine will handle the conversion
|
||||
quote! {
|
||||
#name.to_string()
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Determine if the return type needs conversion
|
||||
let return_type_str = quote! { #return_type }.to_string();
|
||||
|
||||
// Generate the client function with appropriate type conversions
|
||||
let client_fn = if return_type_str.contains("i32") || return_type_str.contains("u32") {
|
||||
// For integer return types that need conversion
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_strings),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<i64>(&script) {
|
||||
Ok(result) => result as #return_type,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
0 as #return_type // Use 0 as default for numeric types
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if return_type_str.contains("String") {
|
||||
// For String return type
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_strings),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<#return_type>(&script) {
|
||||
Ok(result) => result,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
String::new() // Empty string as default
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if return_type_str.contains("bool") {
|
||||
// For boolean return type
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_strings),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<#return_type>(&script) {
|
||||
Ok(result) => result,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
false // False as default
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// For complex types or other types
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_strings),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<#return_type>(&script) {
|
||||
Ok(result) => result,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
panic!("Failed to evaluate Rhai script: {}", err) // Panic for complex types
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Combine the original function and the generated client function
|
||||
let output = quote! {
|
||||
#input_fn
|
||||
|
||||
#client_fn
|
||||
};
|
||||
|
||||
output.into()
|
||||
}
|
||||
|
||||
/// A more advanced version of the rhai macro that handles different parameter types better.
|
||||
///
|
||||
/// This version properly escapes strings and handles different parameter types more accurately.
|
||||
/// It's recommended to use this version for more complex functions.
|
||||
#[proc_macro_attribute]
|
||||
pub fn rhai_advanced(_attr: TokenStream, item: TokenStream) -> TokenStream {
|
||||
// Parse the input function
|
||||
let input_fn = parse_macro_input!(item as ItemFn);
|
||||
let fn_name = &input_fn.sig.ident;
|
||||
let fn_name_str = fn_name.to_string();
|
||||
|
||||
// Create the client function name (original + _rhai_client)
|
||||
let client_fn_name = format_ident!("{}_rhai_client", fn_name);
|
||||
|
||||
// Extract function parameters
|
||||
let mut param_names = Vec::new();
|
||||
let mut param_types = Vec::new();
|
||||
let mut param_declarations = Vec::new();
|
||||
|
||||
for arg in &input_fn.sig.inputs {
|
||||
match arg {
|
||||
FnArg::Typed(PatType { pat, ty, .. }) => {
|
||||
if let Pat::Ident(pat_ident) = &**pat {
|
||||
let param_name = &pat_ident.ident;
|
||||
param_names.push(param_name.clone());
|
||||
param_types.push(ty.clone());
|
||||
param_declarations.push(quote! { #param_name: #ty });
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// Skip self parameters
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Determine return type
|
||||
let return_type = match &input_fn.sig.output {
|
||||
ReturnType::Default => parse_quote!(()),
|
||||
ReturnType::Type(_, ty) => ty.clone(),
|
||||
};
|
||||
|
||||
// Generate parameter formatting for the Rhai script
|
||||
let param_format_expressions = param_names
|
||||
.iter()
|
||||
.zip(param_types.iter())
|
||||
.map(|(name, ty)| {
|
||||
let type_str = quote! { #ty }.to_string();
|
||||
|
||||
// Handle different parameter types
|
||||
if type_str.contains("String") {
|
||||
quote! {
|
||||
format!("\"{}\"", #name.replace("\"", "\\\""))
|
||||
}
|
||||
} else if type_str.contains("bool") {
|
||||
quote! {
|
||||
format!("{}", #name)
|
||||
}
|
||||
} else if type_str.contains("i32") || type_str.contains("u32") {
|
||||
// Convert smaller integer types to i64 for Rhai
|
||||
quote! {
|
||||
format!("{}", #name as i64)
|
||||
}
|
||||
} else if type_str.contains("i") || type_str.contains("u") || type_str.contains("f") {
|
||||
// Other numeric types
|
||||
quote! {
|
||||
format!("{}", #name)
|
||||
}
|
||||
} else {
|
||||
// Default for other types
|
||||
quote! {
|
||||
format!("{:?}", #name)
|
||||
}
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
// Determine if the return type needs conversion
|
||||
let return_type_str = quote! { #return_type }.to_string();
|
||||
let needs_return_conversion =
|
||||
return_type_str.contains("i32") || return_type_str.contains("u32");
|
||||
|
||||
// Generate the client function with appropriate type conversions
|
||||
let client_fn = if needs_return_conversion {
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_expressions),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<i64>(&script) {
|
||||
Ok(result) => result as #return_type,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
#return_type::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
quote! {
|
||||
fn #client_fn_name(engine: &rhai::Engine, #(#param_declarations),*) -> #return_type {
|
||||
let script = format!(
|
||||
"{}({})",
|
||||
#fn_name_str,
|
||||
&[#(#param_format_expressions),*].join(", ")
|
||||
);
|
||||
|
||||
match engine.eval::<#return_type>(&script) {
|
||||
Ok(result) => result,
|
||||
Err(err) => {
|
||||
eprintln!("Rhai script error: {}", err);
|
||||
#return_type::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Combine the original function and the generated client function
|
||||
let output = quote! {
|
||||
#input_fn
|
||||
|
||||
#client_fn
|
||||
};
|
||||
|
||||
output.into()
|
||||
}
|
||||
|
||||
/// Macro that generates a module with Rhai client functions for all functions in scope.
|
||||
///
|
||||
/// This macro should be used at the module level to generate Rhai client functions for all
|
||||
/// functions marked with the #[rhai] attribute.
|
||||
#[proc_macro]
|
||||
pub fn generate_rhai_module(_item: TokenStream) -> TokenStream {
|
||||
// This would be a more complex implementation that would need to
|
||||
// scan the module for functions marked with #[rhai] and generate
|
||||
// client functions for all of them.
|
||||
//
|
||||
// For simplicity, we'll just return a placeholder implementation
|
||||
|
||||
let output = quote! {
|
||||
/// Register all functions marked with #[rhai] in this module with the Rhai engine.
|
||||
///
|
||||
/// This function handles type conversions between Rust and Rhai types automatically.
|
||||
/// For example, it converts between Rust's i32 and Rhai's i64 types.
|
||||
pub fn register_rhai_functions(engine: &mut rhai::Engine) {
|
||||
// This would be generated based on the functions in the module
|
||||
println!("Registering Rhai functions...");
|
||||
|
||||
// In a real implementation, this would iterate through all functions
|
||||
// marked with #[rhai] and register them with the engine.
|
||||
}
|
||||
};
|
||||
|
||||
output.into()
|
||||
}
|
||||
Reference in New Issue
Block a user