X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=d927d2ae71c816af9f92ee824861103715117d0f;hb=f5e0e228fd73f0b44381af28c13ffc2df67608c0;hp=ffb70f92001e0b346b65bb97d2703e7d4b1854dd;hpb=56134a2bd123b75448536de5e945374e8b011f92;p=rust-lightning diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index ffb70f92..d927d2ae 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -10,7 +10,7 @@ //! It also generates relevant memory-management functions and free-standing functions with //! parameters mapped. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::env; use std::fs::File; use std::io::{Read, Write}; @@ -38,7 +38,7 @@ fn convert_macro(w: &mut W, macro_path: &syn::Path, stream: & if let Some(s) = types.maybe_resolve_ident(&struct_for) { if !types.crate_types.opaques.get(&s).is_some() { return; } writeln!(w, "#[no_mangle]").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", struct_for, struct_for).unwrap(); + writeln!(w, "pub extern \"C\" fn {}_write(obj: &{}) -> crate::c_types::derived::CVec_u8Z {{", struct_for, struct_for).unwrap(); writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap(); writeln!(w, "}}").unwrap(); writeln!(w, "#[no_mangle]").unwrap(); @@ -65,7 +65,7 @@ fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path let full_obj_path; let mut has_inner = false; if let syn::Type::Path(ref p) = for_ty { - if let Some(ident) = p.path.get_ident() { + if let Some(ident) = single_ident_generic_path_to_ident(&p.path) { for_obj = format!("{}", ident); full_obj_path = for_obj.clone(); has_inner = types.c_type_has_inner_from_path(&types.resolve_path(&p.path, Some(generics))); @@ -83,7 +83,7 @@ fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path match &t as &str { "util::ser::Writeable" => { writeln!(w, "#[no_mangle]").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, full_obj_path).unwrap(); + writeln!(w, "pub extern \"C\" fn {}_write(obj: &{}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, full_obj_path).unwrap(); let ref_type = syn::Type::Reference(syn::TypeReference { and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None, @@ -233,15 +233,20 @@ macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $pat: pat => $e: ex } // First try to resolve path to find in-crate traits, but if that doesn't work // assume its a prelude trait (eg Clone, etc) and just use the single ident. - if let Some(path) = $types.maybe_resolve_path(&supertrait.path, None) { - match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) { - $( $pat => $e, )* + let types_opt: Option<&TypeResolver> = $types; + if let Some(types) = types_opt { + if let Some(path) = types.maybe_resolve_path(&supertrait.path, None) { + match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) { + $( $pat => $e, )* + } + continue; } - } else if let Some(ident) = supertrait.path.get_ident() { + } + if let Some(ident) = supertrait.path.get_ident() { match (&format!("{}", ident) as &str, &ident) { $( $pat => $e, )* } - } else { + } else if types_opt.is_some() { panic!("Supertrait unresolvable and not single-ident"); } }, @@ -337,7 +342,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty } } // Add functions which may be required for supertrait implementations. - walk_supertraits!(t, types, ( + walk_supertraits!(t, Some(&types), ( ("Clone", _) => { writeln!(w, "\tpub clone: Option *mut c_void>,").unwrap(); generated_fields.push("clone".to_owned()); @@ -368,7 +373,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty generated_fields.push("free".to_owned()); writeln!(w, "}}").unwrap(); // Implement supertraits for the C-mapped struct. - walk_supertraits!(t, types, ( + walk_supertraits!(t, Some(&types), ( ("Send", _) => writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap(), ("Sync", _) => writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap(), ("std::cmp::Eq", _) => { @@ -550,40 +555,22 @@ fn writeln_opaque(w: &mut W, ident: &syn::Ident, struct_name: writeln!(w, "\t\tret").unwrap(); writeln!(w, "\t}}\n}}").unwrap(); - 'attr_loop: for attr in attrs.iter() { - let tokens_clone = attr.tokens.clone(); - let mut token_iter = tokens_clone.into_iter(); - if let Some(token) = token_iter.next() { - match token { - TokenTree::Group(g) => { - if format!("{}", single_ident_generic_path_to_ident(&attr.path).unwrap()) == "derive" { - for id in g.stream().into_iter() { - if let TokenTree::Ident(i) = id { - if i == "Clone" { - writeln!(w, "impl Clone for {} {{", struct_name).unwrap(); - writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); - writeln!(w, "\t\tSelf {{").unwrap(); - writeln!(w, "\t\t\tinner: Box::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())),").unwrap(); - writeln!(w, "\t\t\tis_owned: true,").unwrap(); - writeln!(w, "\t\t}}\n\t}}\n}}").unwrap(); - writeln!(w, "#[allow(unused)]").unwrap(); - writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap(); - writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", struct_name).unwrap(); - writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *mut native{})).clone() }})) as *mut c_void", struct_name).unwrap(); - writeln!(w, "}}").unwrap(); - writeln!(w, "#[no_mangle]").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", struct_name, struct_name, struct_name).unwrap(); - writeln!(w, "\t{} {{ inner: Box::into_raw(Box::new(unsafe {{ &*orig.inner }}.clone())), is_owned: true }}", struct_name).unwrap(); - writeln!(w, "}}").unwrap(); - break 'attr_loop; - } - } - } - } - }, - _ => {}, - } - } + if attrs_derives_clone(attrs) { + writeln!(w, "impl Clone for {} {{", struct_name).unwrap(); + writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); + writeln!(w, "\t\tSelf {{").unwrap(); + writeln!(w, "\t\t\tinner: Box::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())),").unwrap(); + writeln!(w, "\t\t\tis_owned: true,").unwrap(); + writeln!(w, "\t\t}}\n\t}}\n}}").unwrap(); + writeln!(w, "#[allow(unused)]").unwrap(); + writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap(); + writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", struct_name).unwrap(); + writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *mut native{})).clone() }})) as *mut c_void", struct_name).unwrap(); + writeln!(w, "}}").unwrap(); + writeln!(w, "#[no_mangle]").unwrap(); + writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", struct_name, struct_name, struct_name).unwrap(); + writeln!(w, "\t{} {{ inner: Box::into_raw(Box::new(unsafe {{ &*orig.inner }}.clone())), is_owned: true }}", struct_name).unwrap(); + writeln!(w, "}}").unwrap(); } write_cpp_wrapper(cpp_headers, &format!("{}", ident), true); @@ -706,6 +693,11 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, /// /// A few non-crate Traits are hard-coded including Default. fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut TypeResolver) { + match export_status(&i.attrs) { + ExportStatus::Export => {}, + ExportStatus::NoExport|ExportStatus::TestOnly => return, + } + if let syn::Type::Tuple(_) = &*i.self_ty { if types.understood_c_type(&*i.self_ty, None) { let mut gen_types = GenericTypes::new(); @@ -786,7 +778,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap(); writeln!(w, "\t\tret\n\t}}\n}}").unwrap(); - write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: *const {}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap(); + write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: &{}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap(); writeln!(w, "\tcrate::{} {{", full_trait_path).unwrap(); writeln!(w, "\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap(); writeln!(w, "\t\tfree: None,").unwrap(); @@ -827,7 +819,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ _ => {}, } } - walk_supertraits!(trait_obj, types, ( + walk_supertraits!(trait_obj, Some(&types), ( ("Clone", _) => { writeln!(w, "\t\tclone: Some({}_clone_void),", ident).unwrap(); }, @@ -925,7 +917,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ _ => unimplemented!(), } } - walk_supertraits!(trait_obj, types, ( + walk_supertraits!(trait_obj, Some(&types), ( (s, t) => { if let Some(supertrait_obj) = types.crate_types.traits.get(s).cloned() { writeln!(w, "use {}::{} as native{}Trait;", types.orig_crate, s, t).unwrap(); @@ -952,10 +944,9 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ }, "PartialEq" => {}, // If we have no generics, try a manual implementation: - _ if p.path.get_ident().is_some() => maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types), - _ => {}, + _ => maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types), } - } else if p.path.get_ident().is_some() { + } else { // If we have no generics, try a manual implementation: maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types); } @@ -1475,6 +1466,10 @@ fn walk_ast<'a>(in_dir: &str, path: &str, module: String, ast_storage: &'a FullL ExportStatus::NoExport|ExportStatus::TestOnly => continue, } let struct_path = format!("{}::{}", module, s.ident); + if attrs_derives_clone(&s.attrs) { + crate_types.clonable_types.insert("crate::".to_owned() + &struct_path); + } + crate_types.opaques.insert(struct_path, &s.ident); } }, @@ -1485,6 +1480,12 @@ fn walk_ast<'a>(in_dir: &str, path: &str, module: String, ast_storage: &'a FullL ExportStatus::NoExport|ExportStatus::TestOnly => continue, } let trait_path = format!("{}::{}", module, t.ident); + walk_supertraits!(t, None, ( + ("Clone", _) => { + crate_types.clonable_types.insert("crate::".to_owned() + &trait_path); + }, + (_, _) => {} + ) ); crate_types.traits.insert(trait_path, &t); } }, @@ -1520,6 +1521,9 @@ fn walk_ast<'a>(in_dir: &str, path: &str, module: String, ast_storage: &'a FullL ExportStatus::NoExport|ExportStatus::TestOnly => continue, } let enum_path = format!("{}::{}", module, e.ident); + if attrs_derives_clone(&e.attrs) { + crate_types.clonable_types.insert("crate::".to_owned() + &enum_path); + } crate_types.opaques.insert(enum_path, &e.ident); } }, @@ -1530,6 +1534,9 @@ fn walk_ast<'a>(in_dir: &str, path: &str, module: String, ast_storage: &'a FullL ExportStatus::NoExport|ExportStatus::TestOnly => continue, } let enum_path = format!("{}::{}", module, e.ident); + if attrs_derives_clone(&e.attrs) { + crate_types.clonable_types.insert("crate::".to_owned() + &enum_path); + } crate_types.mirrored_enums.insert(enum_path, &e); } }, @@ -1552,10 +1559,18 @@ fn main() { let mut cpp_header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true) .open(&args[6]).expect("Unable to open new header file"); - writeln!(header_file, "#if defined(__GNUC__)\n#define MUST_USE_STRUCT __attribute__((warn_unused))").unwrap(); - writeln!(header_file, "#else\n#define MUST_USE_STRUCT\n#endif").unwrap(); - writeln!(header_file, "#if defined(__GNUC__)\n#define MUST_USE_RES __attribute__((warn_unused_result))").unwrap(); - writeln!(header_file, "#else\n#define MUST_USE_RES\n#endif").unwrap(); + writeln!(header_file, "#if defined(__GNUC__)").unwrap(); + writeln!(header_file, "#define MUST_USE_STRUCT __attribute__((warn_unused))").unwrap(); + writeln!(header_file, "#define MUST_USE_RES __attribute__((warn_unused_result))").unwrap(); + writeln!(header_file, "#else").unwrap(); + writeln!(header_file, "#define MUST_USE_STRUCT").unwrap(); + writeln!(header_file, "#define MUST_USE_RES").unwrap(); + writeln!(header_file, "#endif").unwrap(); + writeln!(header_file, "#if defined(__clang__)").unwrap(); + writeln!(header_file, "#define NONNULL_PTR _Nonnull").unwrap(); + writeln!(header_file, "#else").unwrap(); + writeln!(header_file, "#define NONNULL_PTR").unwrap(); + writeln!(header_file, "#endif").unwrap(); writeln!(cpp_header_file, "#include \nnamespace LDK {{").unwrap(); // First parse the full crate's ASTs, caching them so that we can hold references to the AST @@ -1566,7 +1581,8 @@ fn main() { // ...then walk the ASTs tracking what types we will map, and how, so that we can resolve them // when parsing other file ASTs... let mut libtypes = CrateTypes { traits: HashMap::new(), opaques: HashMap::new(), mirrored_enums: HashMap::new(), - type_aliases: HashMap::new(), templates_defined: HashMap::default(), template_file: &mut derived_templates }; + type_aliases: HashMap::new(), templates_defined: HashMap::default(), template_file: &mut derived_templates, + clonable_types: HashSet::new() }; walk_ast(&args[1], "/lib.rs", "".to_string(), &libast, &mut libtypes); // ... finally, do the actual file conversion/mapping, writing out types as we go.