From 75e8cf5acf256d8ecaf0c68e60997f6423e83c04 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Wed, 21 Jul 2021 18:51:54 +0000 Subject: [PATCH] Expose struct method calls on trait structs to C++ directly We can add method calls for non-trait structs later, but this is particularly useful as otherwise you need to extract both the method and the `this_arg` to make the call. --- c-bindings-gen/src/blocks.rs | 10 +++++- c-bindings-gen/src/main.rs | 49 +++++++++++++++++---------- genbindings.sh | 64 ++++++++++++++++++++++++++++++++++++ 3 files changed, 104 insertions(+), 19 deletions(-) diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 82b10ad..643a8be 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -20,7 +20,7 @@ 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(); @@ -39,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(); } diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index 4c14074..c8adf7d 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -237,7 +237,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\t/// An opaque pointer which is passed to your function implementations as an argument.").unwrap(); writeln!(w, "\t/// This has no meaning in the LDK, and can be NULL or any other value.").unwrap(); writeln!(w, "\tpub this_arg: *mut c_void,").unwrap(); - let mut generated_fields = Vec::new(); // Every field's (name, Option) except this_arg, used in Clone generation + // We store every field's (name, Option, docs) except this_arg, used in Clone generation + // docs is only set if its a function which should be callable on the object itself in C++ + let mut generated_fields = Vec::new(); for item in t.items.iter() { match item { &syn::TraitItem::Method(ref m) => { @@ -271,14 +273,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty // happen) as well as provide an Option<>al function pointer which is // called when the trait method is called which allows updating on the fly. write!(w, "\tpub {}: ", m.sig.ident).unwrap(); - generated_fields.push((format!("{}", m.sig.ident), None)); + generated_fields.push((format!("{}", m.sig.ident), None, None)); types.write_c_type(w, &*r.elem, Some(&meth_gen_types), false); writeln!(w, ",").unwrap(); writeln!(w, "\t/// Fill in the {} field as a reference to it will be given to Rust after this returns", m.sig.ident).unwrap(); writeln!(w, "\t/// Note that this takes a pointer to this object, not the this_ptr like other methods do").unwrap(); writeln!(w, "\t/// This function pointer may be NULL if {} is filled in when this object is created and never needs updating.", m.sig.ident).unwrap(); writeln!(w, "\tpub set_{}: Option,", m.sig.ident, trait_name).unwrap(); - generated_fields.push((format!("set_{}", m.sig.ident), None)); + generated_fields.push((format!("set_{}", m.sig.ident), None, None)); // Note that cbindgen will now generate // typedef struct Thing {..., set_thing: (const struct Thing*), ...} Thing; // which does not compile since Thing is not defined before it is used. @@ -290,8 +292,12 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\t#[must_use]").unwrap(); } + let mut cpp_docs = Vec::new(); + writeln_docs(&mut cpp_docs, &m.attrs, "\t * "); + let docs_string = "\t/**\n".to_owned() + &String::from_utf8(cpp_docs).unwrap().replace("///", "") + "\t */\n"; + write!(w, "\tpub {}: extern \"C\" fn (", m.sig.ident).unwrap(); - generated_fields.push((format!("{}", m.sig.ident), None)); + generated_fields.push((format!("{}", m.sig.ident), None, Some(docs_string))); write_method_params(w, &m.sig, "c_void", types, Some(&meth_gen_types), true, false); writeln!(w, ",").unwrap(); }, @@ -306,26 +312,32 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\t/// The new {} is provided, and should be mutated as needed to perform a", trait_name).unwrap(); writeln!(w, "\t/// deep copy of the object pointed to by this_arg or avoid any double-freeing.").unwrap(); writeln!(w, "\tpub cloned: Option,", trait_name, trait_name).unwrap(); - generated_fields.push(("cloned".to_owned(), None)); + generated_fields.push(("cloned".to_owned(), None, None)); }, ("std::cmp::Eq", _)|("core::cmp::Eq", _) => { - writeln!(w, "\t/// Checks if two objects are equal given this object's this_arg pointer and another object.").unwrap(); + let eq_docs = "Checks if two objects are equal given this object's this_arg pointer and another object."; + writeln!(w, "\t/// {}", eq_docs).unwrap(); writeln!(w, "\tpub eq: extern \"C\" fn (this_arg: *const c_void, other_arg: &{}) -> bool,", trait_name).unwrap(); - generated_fields.push(("eq".to_owned(), None)); + generated_fields.push(("eq".to_owned(), None, Some(format!("\t/** {} */\n", eq_docs)))); }, ("std::hash::Hash", _)|("core::hash::Hash", _) => { - writeln!(w, "\t/// Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.").unwrap(); - writeln!(w, "\t/// This is used, for example, for inclusion of this object in a hash map.").unwrap(); + let hash_docs_a = "Calculate a succinct non-cryptographic hash for an object given its this_arg pointer."; + let hash_docs_b = "This is used, for example, for inclusion of this object in a hash map."; + writeln!(w, "\t/// {}", hash_docs_a).unwrap(); + writeln!(w, "\t/// {}", hash_docs_b).unwrap(); writeln!(w, "\tpub hash: extern \"C\" fn (this_arg: *const c_void) -> u64,").unwrap(); - generated_fields.push(("hash".to_owned(), None)); + generated_fields.push(("hash".to_owned(), None, + Some(format!("\t/**\n\t * {}\n\t * {}\n\t */\n", hash_docs_a, hash_docs_b)))); }, ("Send", _) => {}, ("Sync", _) => {}, (s, i) => { + // TODO: Both of the below should expose supertrait methods in C++, but doing so is + // nontrivial. generated_fields.push(if types.crate_types.traits.get(s).is_none() { let (docs, name, ret) = convert_trait_impl_field(s); writeln!(w, "\t/// {}", docs).unwrap(); writeln!(w, "\tpub {}: extern \"C\" fn (this_arg: *const c_void) -> {},", name, ret).unwrap(); - (name, None) // Assume clonable + (name, None, None) // Assume clonable } else { // For in-crate supertraits, just store a C-mapped copy of the supertrait as a member. writeln!(w, "\t/// Implementation of {} for this object.", i).unwrap(); @@ -333,14 +345,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\tpub {}: crate::{},", i, s).unwrap(); (format!("{}", i), if !is_clonable { Some(format!("crate::{}_clone_fields", s)) - } else { None }) + } else { None }, None) }); } ) ); writeln!(w, "\t/// Frees any resources associated with this object given its this_arg pointer.").unwrap(); writeln!(w, "\t/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.").unwrap(); writeln!(w, "\tpub free: Option,").unwrap(); - generated_fields.push(("free".to_owned(), None)); + generated_fields.push(("free".to_owned(), None, None)); writeln!(w, "}}").unwrap(); macro_rules! impl_trait_for_c { @@ -449,7 +461,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "pub(crate) extern \"C\" fn {}_clone_fields(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap(); writeln!(w, "\t{} {{", trait_name).unwrap(); writeln!(w, "\t\tthis_arg: orig.this_arg,").unwrap(); - for (field, clone_fn) in generated_fields.iter() { + for (field, clone_fn, _) in generated_fields.iter() { if let Some(f) = clone_fn { // If the field isn't clonable, blindly assume its a trait and hope for the best. writeln!(w, "\t\t{}: {}(&orig.{}),", field, f, field).unwrap(); @@ -522,7 +534,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\t\t\tf(self.this_arg);").unwrap(); writeln!(w, "\t\t}}\n\t}}\n}}").unwrap(); - write_cpp_wrapper(cpp_headers, &trait_name, true); + write_cpp_wrapper(cpp_headers, &trait_name, true, Some(generated_fields.drain(..) + .filter_map(|(name, _, docs)| if let Some(docs) = docs { Some((name, docs)) } else { None }).collect())); } /// Write out a simple "opaque" type (eg structs) which contain a pointer to the native Rust type @@ -567,7 +580,7 @@ fn writeln_opaque(w: &mut W, ident: &syn::Ident, struct_name: writeln!(w, "\t\tret").unwrap(); writeln!(w, "\t}}\n}}").unwrap(); - write_cpp_wrapper(cpp_headers, &format!("{}", ident), true); + write_cpp_wrapper(cpp_headers, &format!("{}", ident), true, None); } /// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate @@ -1360,7 +1373,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", e.ident, e.ident, e.ident).unwrap(); writeln!(w, "\torig.clone()").unwrap(); writeln!(w, "}}").unwrap(); - write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free); + write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free, None); } fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: &mut TypeResolver<'b, 'a>) { @@ -1744,7 +1757,7 @@ fn main() { // For container templates which we created while walking the crate, make sure we add C++ // mapped types so that C++ users can utilize the auto-destructors available. for (ty, has_destructor) in libtypes.templates_defined.borrow().iter() { - write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor); + write_cpp_wrapper(&mut cpp_header_file, ty, *has_destructor, None); } writeln!(cpp_header_file, "}}").unwrap(); diff --git a/genbindings.sh b/genbindings.sh index 7afc274..c1bfc8d 100755 --- a/genbindings.sh +++ b/genbindings.sh @@ -207,6 +207,70 @@ else sed -i 's/#include /#include "ldk_rust_types.h"/g' include/lightning.h fi +# Build C++ class methods which call trait methods +set +x # Echoing every command is very verbose here +OLD_IFS="$IFS" +export IFS='' +echo '#include ' > include/lightningpp_new.hpp +echo 'namespace LDK {' >> include/lightningpp_new.hpp +echo '// Forward declarations' >> include/lightningpp_new.hpp +cat include/lightningpp.hpp | sed -n 's/class \(.*\) {/class \1;/p' >> include/lightningpp_new.hpp +echo '' >> include/lightningpp_new.hpp + +DECLS="" +while read LINE; do + case "$LINE" in + "#include ") + # We already printed this above. + ;; + "namespace LDK {") + # We already printed this above. + ;; + "}") + # We'll print this at the end + ;; + "XXX"*) + STRUCT_NAME="$(echo "$LINE" | awk '{ print $2 }')" + METHOD_NAME="$(echo "$LINE" | awk '{ print $3 }')" + STRUCT_CONTENTS="$(cat include/lightning.h | sed -n -e "/struct LDK$STRUCT_NAME/{:s" -e "/\} LDK$STRUCT_NAME;/!{N" -e "b s" -e "}" -e p -e "}")" + METHOD="$(echo "$STRUCT_CONTENTS" | grep "(\*$METHOD_NAME)")" + if [ "$METHOD" = "" ]; then + echo "Unable to find method declaration for $LINE" + exit 1 + fi + RETVAL="$(echo "$METHOD" | sed 's/[ ]*\([A-Za-z0-9 _]*\)(\*\(.*\)).*/\1/' | sed 's/^struct LDK/LDK::/g' | tr -d ' ')" + [ "$RETVAL" = "LDK::SecretKey" ] && RETVAL="LDKSecretKey" + [ "$RETVAL" = "LDK::PublicKey" ] && RETVAL="LDKPublicKey" + [ "$RETVAL" = "LDK::ThirtyTwoBytes" ] && RETVAL="LDKThirtyTwoBytes" + PARAMS="$(echo "$METHOD" | sed 's/.*(\*.*)(\(const \)*void \*this_arg\(, \)*\(.*\));/\3/')" + + echo -e "\tinline $RETVAL $METHOD_NAME($PARAMS);" >> include/lightningpp_new.hpp + DECLS="$DECLS"$'\n'"inline $RETVAL $STRUCT_NAME::$METHOD_NAME($PARAMS) {" + + DECLS="$DECLS"$'\n'$'\t' + [ "$RETVAL" != "void" ] && DECLS="$DECLS$RETVAL ret = " + DECLS="$DECLS(self.$METHOD_NAME)(self.this_arg" + + IFS=','; for PARAM in $PARAMS; do + DECLS="$DECLS, " + DECLS="$DECLS$(echo $PARAM | sed 's/.* (*\**\([a-zA-Z0-9_]*\)\()[\[0-9\]*]\)*/\1/')" + done + IFS='' + + DECLS="$DECLS);" + [ "$RETVAL" != "void" ] && DECLS="$DECLS"$'\n'$'\t'"return ret;" + DECLS="$DECLS"$'\n'"}" + ;; + *) + echo "$LINE" >> include/lightningpp_new.hpp + esac +done < include/lightningpp.hpp +echo "$DECLS" >> include/lightningpp_new.hpp +echo "}" >> include/lightningpp_new.hpp +export IFS="$OLD_IFS" +set -x +mv include/lightningpp_new.hpp include/lightningpp.hpp + # Finally, sanity-check the generated C and C++ bindings with demo apps: # Naively run the C demo app: gcc $LOCAL_CFLAGS -Wall -g -pthread demo.c target/debug/libldk.a -ldl -- 2.30.2