X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fblocks.rs;fp=c-bindings-gen%2Fsrc%2Fblocks.rs;h=9c404411a2719d4b979e8b920d1f0ef516e7b3c8;hb=787d5d9810dfc71006f3ed0c8a21290be5ea6c54;hp=643a8be7c3c1fdb5052dde93872d3b14456c3e95;hpb=75e8cf5acf256d8ecaf0c68e60997f6423e83c04;p=ldk-c-bindings diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 643a8be..9c40441 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -377,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(); @@ -414,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