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<Vec<(String, String)>>) {
writeln!(cpp_header_file, "class {} {{", ty).unwrap();
writeln!(cpp_header_file, "private:").unwrap();
writeln!(cpp_header_file, "\tLDK{} self;", ty).unwrap();
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();
}
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<crate::c_types::CResultTempl<{}, {}>> 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<crate::c_types::CResultTempl<{}, {}>> 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();
}
}
+/// 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<Item = &'a syn::FnArg> {
+ 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: std::io::Write>(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<Item = (String, &'a syn::Type)> {
+ writeln_docs_impl(w, attrs, prefix, Some((types, generics, args, ret, None)))
+}
+
+pub fn writeln_field_docs<W: std::io::Write>(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<Item = (String, &'a syn::Type)> {
for attr in attrs.iter() {
let tokens_clone = attr.tokens.clone();
let mut token_iter = tokens_clone.into_iter();
},
}
}
+ 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
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;
},
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);
},
_ => {},
}
/// 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: std::io::Write>(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(_) => {},
},
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!(),
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;
}
// 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();
}
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);
}
}
/// 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: std::io::Write>(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();
projects / ldk-c-bindings / blobdiff