use macros to handle stuff, adds more useful errors

Author: jupyterkat

crates/byondapi-macros/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "byondapi-macros"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["lib"]
+
+[dependencies]
+inventory = "0.3.15"
+byondapi-impl = { path = "./byondapi-impl", package = "byondapi-impl" }

crates/byondapi-macros/byondapi-impl/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "byondapi-impl"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+inventory = "0.3.15"
+quote = "1.0"
+proc-macro2 = "1.0"
+
+[dependencies.syn]
+version = "2.0"
+features = ["full", "parsing", "printing"]

crates/byondapi-macros/byondapi-impl/src/lib.rs

@@ -0,0 +1,255 @@
+use proc_macro::TokenStream;
+use proc_macro2::Ident;
+use quote::quote;
+use syn::{spanned::Spanned, Lit};
+
+fn extract_args(a: &syn::FnArg) -> &syn::PatType {
+    match a {
+        syn::FnArg::Typed(p) => p,
+        _ => panic!("Not supported on types with `self`!"),
+    }
+}
+//this is an example, mr clippy
+#[allow(clippy::test_attr_in_doctest)]
+/// Macro for generating byond binds
+/// Usage:
+/// ```
+/// use byondapi::prelude::*;
+/// #[byondapi::bind]
+/// fn example() {Ok(ByondValue::null())}
+///
+/// #[byondapi::bind("/datum/example/proc/other_example")]
+/// fn example_other(_: ByondValue, _: ByondValue) {Ok(ByondValue::null())}
+///
+/// ```
+/// Then generate the bindings.dm file with
+/// ```
+/// #[test]
+/// fn generate_binds() {
+///     byondapi::byondapi_macros::generate_bindings(env!("CARGO_CRATE_NAME"));
+/// }
+/// ```
+/// and run cargo test to actually create the file
+///
+#[proc_macro_attribute]
+pub fn bind(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let proc = syn::parse_macro_input!(attr as Option<syn::Lit>);
+
+    let func_name = &input.sig.ident;
+    let func_name_disp = quote!(#func_name).to_string();
+
+    let func_name_ffi = format!("{func_name_disp}_ffi");
+    let func_name_ffi = Ident::new(&func_name_ffi, func_name.span());
+    let func_name_ffi_disp = quote!(#func_name_ffi).to_string();
+
+    let args = &input.sig.inputs;
+
+    //Check for returns
+    match &input.sig.output {
+        syn::ReturnType::Default => {} //
+
+        syn::ReturnType::Type(_, ty) => {
+            return syn::Error::new(ty.span(), "Do not specify the return value of binds")
+                .to_compile_error()
+                .into()
+        }
+    }
+
+    let signature = quote! {
+        #[no_mangle]
+        pub unsafe extern "C" fn #func_name_ffi (
+            __argc: ::byondapi::sys::u4c,
+            __argv: *mut ::byondapi::value::ByondValue
+        ) -> ::byondapi::value::ByondValue
+    };
+
+    let body = &input.block;
+    let mut arg_names: syn::punctuated::Punctuated<syn::Ident, syn::Token![,]> =
+        syn::punctuated::Punctuated::new();
+    let mut proc_arg_unpacker: syn::punctuated::Punctuated<
+        proc_macro2::TokenStream,
+        syn::Token![,],
+    > = syn::punctuated::Punctuated::new();
+
+    for arg in args.iter().map(extract_args) {
+        if let syn::Pat::Ident(p) = &*arg.pat {
+            arg_names.push(p.ident.clone());
+            let index = arg_names.len() - 1;
+            proc_arg_unpacker.push(quote! {
+                args.get(#index).map(::byondapi::value::ByondValue::clone).unwrap_or_default()
+            });
+        }
+    }
+
+    let arg_names_disp = quote!(#arg_names).to_string();
+
+    //Submit to inventory
+    let cthook_prelude = match &proc {
+        Some(Lit::Str(p)) => {
+            quote! {
+                ::byondapi::byondapi_macros::inventory::submit!({
+                    ::byondapi::byondapi_macros::Bind {
+                        proc_path: #p,
+                        func_name: #func_name_ffi_disp,
+                        func_arguments: #arg_names_disp,
+                        is_variadic: false,
+                    }
+                });
+            }
+        }
+        Some(other_literal) => {
+            return syn::Error::new(
+                other_literal.span(),
+                "Bind attributes must be a string literal or empty",
+            )
+            .to_compile_error()
+            .into()
+        }
+        None => {
+            let mut func_name_disp = func_name_disp.clone();
+            func_name_disp.insert_str(0, "/proc/");
+            quote! {
+                ::byondapi::byondapi_macros::inventory::submit!({
+                    ::byondapi::byondapi_macros::Bind{
+                        proc_path: #func_name_disp,
+                        func_name: #func_name_ffi_disp,
+                        func_arguments: #arg_names_disp,
+                        is_variadic: false,
+                    }
+                });
+            }
+        }
+    };
+
+    let result = quote! {
+        #cthook_prelude
+        #signature {
+            let args = unsafe { ::byondapi::parse_args(__argc, __argv) };
+            match #func_name(#proc_arg_unpacker) {
+                Ok(val) => val,
+                Err(e) => {
+                    let error_string = ::byondapi::value::ByondValue::try_from(e.0).unwrap();
+                    ::byondapi::global_call::call_global_id(byond_string!("stack_trace"), &[error_string]).unwrap();
+                    ::byondapi::value::ByondValue::null()
+                }
+            }
+
+        }
+        fn #func_name(#args) -> Result<::byondapi::value::ByondValue, ::byondapi::BindError>
+        #body
+    };
+    result.into()
+}
+
+/// Same as [`bind`] but accepts variable amount of args, with src in the beginning if there's a src
+/// The args are just a variable named `args` in the macro'd function
+#[proc_macro_attribute]
+pub fn bind_raw_args(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let proc = syn::parse_macro_input!(attr as Option<syn::Lit>);
+
+    let func_name = &input.sig.ident;
+    let func_name_disp = quote!(#func_name).to_string();
+
+    let func_name_ffi = format!("{func_name_disp}_ffi");
+    let func_name_ffi = Ident::new(&func_name_ffi, func_name.span());
+    let func_name_ffi_disp = quote!(#func_name_ffi).to_string();
+
+    //Check for returns
+    match &input.sig.output {
+        syn::ReturnType::Default => {} //
+
+        syn::ReturnType::Type(_, ty) => {
+            return syn::Error::new(ty.span(), "Do not specify the return value of binds")
+                .to_compile_error()
+                .into()
+        }
+    }
+
+    if !input.sig.inputs.is_empty() {
+        return syn::Error::new(
+            input.sig.inputs.span(),
+            "Do not specify arguments for raw arg binds",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let signature = quote! {
+        #[no_mangle]
+        pub unsafe extern "C" fn #func_name_ffi (
+            __argc: ::byondapi::sys::u4c,
+            __argv: *mut ::byondapi::value::ByondValue
+        ) -> ::byondapi::value::ByondValue
+    };
+
+    let body = &input.block;
+
+    //Submit to inventory
+    let cthook_prelude = match proc {
+        Some(Lit::Str(p)) => {
+            quote! {
+                ::byondapi::byondapi_macros::inventory::submit!({
+                    ::byondapi::byondapi_macros::Bind {
+                        proc_path: #p,
+                        func_name: #func_name_ffi_disp,
+                        func_arguments: "",
+                        is_variadic: true,
+                    }
+                });
+            }
+        }
+        Some(other_literal) => {
+            return syn::Error::new(
+                other_literal.span(),
+                "Bind attributes must be a string literal or empty",
+            )
+            .to_compile_error()
+            .into()
+        }
+        None => {
+            let mut func_name_disp = func_name_disp.clone();
+            func_name_disp.insert_str(0, "/proc/");
+            quote! {
+                    ::byondapi::byondapi_macros::inventory::submit!({
+                        ::byondapi::byondapi_macros::Bind{
+                            proc_path: #func_name_disp,
+                            func_name: #func_name_ffi_disp,
+                            func_arguments: "",
+                            is_variadic: true,
+                        }
+                    });
+            }
+        }
+    };
+
+    let result = quote! {
+        #cthook_prelude
+        #signature {
+            let mut args = unsafe { ::byondapi::parse_args(__argc, __argv) };
+            match #func_name(args) {
+                Ok(val) => val,
+                Err(e) => {
+                    let error_string = ::byondapi::value::ByondValue::try_from(e.0).unwrap();
+                    ::byondapi::global_call::call_global_id(byond_string!("stack_trace"), &[error_string]).unwrap();
+                    ::byondapi::value::ByondValue::null()
+                }
+            }
+        }
+        fn #func_name(args: &mut [::byondapi::value::ByondValue]) -> Result<::byondapi::value::ByondValue, ::byondapi::BindError>
+        #body
+    };
+    result.into()
+}
+
+#[proc_macro_attribute]
+pub fn init(_: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+    let func_name = &input.sig.ident;
+    quote! {
+        #input
+        ::byondapi::byondapi_macros::inventory::submit!({::byondapi::InitFunc(#func_name)});
+    }
+    .into()
+}

crates/byondapi-macros/src/lib.rs

@@ -0,0 +1,66 @@
+use std::io::Write;
+
+pub use byondapi_impl::{bind, bind_raw_args, init};
+
+pub use inventory;
+
+pub struct Bind {
+    pub proc_path: &'static str,
+    pub func_name: &'static str,
+    pub func_arguments: &'static str,
+    pub is_variadic: bool,
+}
+
+inventory::collect!(Bind);
+
+pub fn generate_bindings(libname: &str) {
+    _ = std::fs::remove_file("./bindings.dm");
+    let mut file = std::fs::File::create("./bindings.dm").unwrap();
+    let libname_upper = libname.to_uppercase();
+    file.write_fmt(format_args!(
+        "//THIS FILE IS AUTOMATICALLY GENERATED BY {libname_upper}, PLEASE DO NOT TOUCH IT
+//PROC DEFINITIONS MAY MOVE AROUND, THIS IS NORMAL
+
+/* This comment bypasses grep checks */ /var/__{libname}
+
+/proc/__detect_{libname}()
+	if (world.system_type == UNIX)
+		return __{libname} = \"lib{libname}\"
+	else
+		return __{libname} = \"{libname}\"
+
+#define {libname_upper} (__{libname} || __detect_{libname}())
+    
+"
+    ))
+    .unwrap();
+    for thing in inventory::iter::<Bind> {
+        let path = thing.proc_path;
+        let func_name = thing.func_name;
+        let func_arguments = thing.func_arguments;
+        let func_arguments_srcless = func_arguments
+            .to_owned()
+            .replace("src, ", "")
+            .replace("src", "");
+        if thing.is_variadic {
+            //can't directly modify args, fuck you byond
+            file.write_fmt(format_args!(
+                r#"{path}(...)
+	var/list/args_copy = args.Copy()
+	args_copy.Insert(1, src)
+	return call_ext({libname_upper}, "byond:{func_name}")(arglist(args_copy))
+
+"#
+            ))
+            .unwrap()
+        } else {
+            file.write_fmt(format_args!(
+                r#"{path}({func_arguments_srcless})
+	return call_ext({libname_upper}, "byond:{func_name}")({func_arguments})
+
+"#
+            ))
+            .unwrap()
+        }
+    }
+}

crates/byondapi-rs-test/Cargo.toml

@@ -12,3 +12,4 @@ crate-type = ["cdylib"]
 byondapi = { path = "../byondapi-rs" }
 tempfile = "3.8.1"
 cargo_metadata = "0.18.1"
+eyre = "0.6.12"