X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fblocks.rs;h=9c404411a2719d4b979e8b920d1f0ef516e7b3c8;hp=bbb41e09f5df03adab603bbb9cfc701503e8060d;hb=a82e075188fc15a103234832686915c196bfe240;hpb=d7aaec88584beeb1cece72259f68382f2a729440 diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index bbb41e0..9c40441 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -11,14 +11,16 @@ use std::fs::File; use std::io::Write; -use proc_macro2::{TokenTree, Span}; + +use proc_macro2::TokenTree; +use quote::format_ident; use crate::types::*; /// Writes out a C++ wrapper class for the given type, which contains various utilities to access /// the underlying C-mapped type safely avoiding some common memory management issues by handling /// resource-freeing and prevending accidental raw copies. -pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool) { +pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool, trait_methods: Option>) { writeln!(cpp_header_file, "class {} {{", ty).unwrap(); writeln!(cpp_header_file, "private:").unwrap(); writeln!(cpp_header_file, "\tLDK{} self;", ty).unwrap(); @@ -37,6 +39,14 @@ pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: b writeln!(cpp_header_file, "\tLDK{}* operator ->() {{ return &self; }}", ty).unwrap(); writeln!(cpp_header_file, "\tconst LDK{}* operator &() const {{ return &self; }}", ty).unwrap(); writeln!(cpp_header_file, "\tconst LDK{}* operator ->() const {{ return &self; }}", ty).unwrap(); + if let Some(methods) = trait_methods { + for (meth_name, meth_docs) in methods { + cpp_header_file.write_all(meth_docs.as_bytes()).unwrap(); + // Note that we have zero logic to print C/C__ code for a given function. Instead, we + // simply use sed to replace the following in genbindings.sh + writeln!(cpp_header_file, "XXX {} {}", ty, meth_name).unwrap(); + } + } writeln!(cpp_header_file, "}};").unwrap(); } @@ -135,12 +145,8 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); - // TODO: Templates should use () now that they can, too - let templ_ok_type = if ok_type != "()" { ok_type } else { "u8" }; - let templ_err_type = if err_type != "()" { err_type } else { "u8" }; - - writeln!(w, "impl From> for {} {{", templ_ok_type, templ_err_type, mangled_container).unwrap(); - writeln!(w, "\tfn from(mut o: crate::c_types::CResultTempl<{}, {}>) -> Self {{", templ_ok_type, templ_err_type).unwrap(); + writeln!(w, "impl From> for {} {{", ok_type, err_type, mangled_container).unwrap(); + writeln!(w, "\tfn from(mut o: crate::c_types::CResultTempl<{}, {}>) -> Self {{", ok_type, err_type).unwrap(); writeln!(w, "\t\tlet contents = if o.result_ok {{").unwrap(); if ok_type != "()" { writeln!(w, "\t\t\tlet result = unsafe {{ o.contents.result }};").unwrap(); @@ -371,8 +377,34 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, } } +/// Prints the docs from a given attribute list unless its tagged no export +pub fn writeln_fn_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: &syn::ReturnType) where I: Iterator { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, + args.filter_map(|arg| if let syn::FnArg::Typed(ty) = arg { + if let syn::Pat::Ident(id) = &*ty.pat { + Some((id.ident.to_string(), &*ty.ty)) + } else { unimplemented!() } + } else { None }), + if let syn::ReturnType::Type(_, ty) = ret { Some(&**ty) } else { None }, + None + ))); +} + /// Prints the docs from a given attribute list unless its tagged no export pub fn writeln_docs(w: &mut W, attrs: &[syn::Attribute], prefix: &str) { + writeln_docs_impl(w, attrs, prefix, None::<(_, _, std::vec::Drain<'_, (String, &syn::Type)>, _, _)>); +} + +pub fn writeln_arg_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: Option<&syn::Type>) where I: Iterator { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, args, ret, None))) +} + +pub fn writeln_field_docs(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, field: &syn::Type) { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, vec![].drain(..), None, Some(field)))) +} + +/// Prints the docs from a given attribute list unless its tagged no export +fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, method_args_ret: Option<(&mut TypeResolver, Option<&GenericTypes>, I, Option<&syn::Type>, Option<&syn::Type>)>) where I: Iterator { for attr in attrs.iter() { let tokens_clone = attr.tokens.clone(); let mut token_iter = tokens_clone.into_iter(); @@ -408,6 +440,51 @@ pub fn writeln_docs(w: &mut W, attrs: &[syn::Attribute], pref }, } } + if let Some((types, generics, inp, outp, field)) = method_args_ret { + let mut nullable_found = false; + for (name, inp) in inp { + if types.skip_arg(inp, generics) { continue; } + if if let syn::Type::Reference(syn::TypeReference { elem, .. }) = inp { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let syn::Type::Path(syn::TypePath { ref path, .. }) = inp { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + nullable_found = true; + writeln!(w, "{}/// Note that {} (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix, name).unwrap(); + } + } + if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = outp { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = outp { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + nullable_found = true; + writeln!(w, "{}/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap(); + } + if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = field { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = field { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + writeln!(w, "{}/// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap(); + } + } + } /// Print the parameters in a method declaration, starting after the open parenthesis, through and @@ -440,14 +517,16 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t for inp in sig.inputs.iter() { match inp { syn::FnArg::Receiver(recv) => { - if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); } - write!(w, "this_arg: {}{}", - match (self_ptr, recv.mutability.is_some()) { - (true, true) => "*mut ", - (true, false) => "*const ", - (false, true) => "&mut ", - (false, false) => "&", - }, this_param).unwrap(); + if !recv.attrs.is_empty() { unimplemented!(); } + write!(w, "{}this_arg: {}{}", if recv.reference.is_none() { "mut " } else { "" }, + if recv.reference.is_some() { + match (self_ptr, recv.mutability.is_some()) { + (true, true) => "*mut ", + (true, false) => "*const ", + (false, true) => "&mut ", + (false, false) => "&", + } + } else { "" }, this_param).unwrap(); assert!(first_arg); first_arg = false; }, @@ -486,12 +565,7 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t return; } } - if let syn::Type::Reference(r) = &**rtype { - // We can't return a reference, cause we allocate things on the stack. - types.write_c_type(w, &*r.elem, generics, true); - } else { - types.write_c_type(w, &*rtype, generics, true); - } + types.write_c_type(w, &*rtype, generics, true); }, _ => {}, } @@ -502,7 +576,7 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t /// mut ret = " assuming the next print will be the unmapped Rust function to call followed by the /// parameters we mapped to/from C here. pub fn write_method_var_decl_body(w: &mut W, sig: &syn::Signature, extra_indent: &str, types: &TypeResolver, generics: Option<&GenericTypes>, to_c: bool) { - let mut num_unused = 0; + let mut num_unused = 0u32; for inp in sig.inputs.iter() { match inp { syn::FnArg::Receiver(_) => {}, @@ -531,7 +605,7 @@ pub fn write_method_var_decl_body(w: &mut W, sig: &syn::Signa }, syn::Pat::Wild(w) => { if !w.attrs.is_empty() { unimplemented!(); } - write_new_var!(syn::Ident::new(&format!("unused_{}", num_unused), Span::call_site()), *arg.ty); + write_new_var!(format_ident!("unused_{}", num_unused), *arg.ty); num_unused += 1; }, _ => unimplemented!(), @@ -559,8 +633,9 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu for inp in sig.inputs.iter() { match inp { syn::FnArg::Receiver(recv) => { - if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); } + if !recv.attrs.is_empty() { unimplemented!(); } if to_c { + if recv.reference.is_none() { unimplemented!(); } write!(w, "self.this_arg").unwrap(); first_arg = false; } @@ -624,7 +699,7 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu // If we're returning "Self" (and not "Self::X"), just do it manually write!(w, "{} {{ inner: Box::into_raw(Box::new(ret)), is_owned: true }}", this_type).unwrap(); } else if to_c { - let new_var = types.write_from_c_conversion_new_var(w, &syn::Ident::new("ret", Span::call_site()), rtype, generics); + let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("ret"), rtype, generics); if new_var { write!(w, "\n\t{}", extra_indent).unwrap(); } @@ -632,13 +707,12 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu write!(w, "ret").unwrap(); types.write_from_c_conversion_suffix(w, &*rtype, generics); } else { - let ret_returned = if let syn::Type::Reference(_) = &**rtype { true } else { false }; - let new_var = types.write_to_c_conversion_new_var(w, &syn::Ident::new("ret", Span::call_site()), &rtype, generics, true); + let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("ret"), &rtype, generics, true); if new_var { write!(w, "\n\t{}", extra_indent).unwrap(); } types.write_to_c_conversion_inline_prefix(w, &rtype, generics, true); - write!(w, "{}ret", if ret_returned && !new_var { "*" } else { "" }).unwrap(); + write!(w, "ret").unwrap(); types.write_to_c_conversion_inline_suffix(w, &rtype, generics, true); } } @@ -649,7 +723,7 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu /// Prints concrete generic parameters for a struct/trait/function, including the less-than and /// greater-than symbols, if any generic parameters are defined. pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_lifetimes: bool) { - let mut gen_types = GenericTypes::new(); + let mut gen_types = GenericTypes::new(None); assert!(gen_types.learn_generics(generics, types)); if !generics.params.is_empty() { write!(w, "<").unwrap();