writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap();
writeln!(w, "}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
+ writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", struct_for).unwrap();
+ writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &*(obj as *const native{}) }})", struct_for).unwrap();
+ writeln!(w, "}}").unwrap();
+ writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice) -> {} {{", struct_for, struct_for).unwrap();
writeln!(w, "\tif let Ok(res) = crate::c_types::deserialize_obj(ser) {{").unwrap();
writeln!(w, "\t\t{} {{ inner: Box::into_raw(Box::new(res)), is_owned: true }}", struct_for).unwrap();
writeln!(w, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, for_obj).unwrap();
writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap();
writeln!(w, "}}").unwrap();
+ writeln!(w, "#[no_mangle]").unwrap();
+ writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", for_obj).unwrap();
+ writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &*(obj as *const native{}) }})", for_obj).unwrap();
+ writeln!(w, "}}").unwrap();
},
"util::ser::Readable" => {
writeln!(w, "#[no_mangle]").unwrap();
}
}
+/// Convert "TraitA : TraitB" to a single function name and return type.
+///
+/// This is (obviously) somewhat over-specialized and only useful for TraitB's that only require a
+/// single function (eg for serialization).
+fn convert_trait_impl_field(trait_path: &str) -> (String, &'static str) {
+ match trait_path {
+ "util::ser::Writeable" => ("write".to_owned(), "crate::c_types::derived::CVec_u8Z"),
+ _ => unimplemented!(),
+ }
+}
+
+/// Companion to convert_trait_impl_field, write an assignment for the function defined by it for
+/// `for_obj` which implements the the trait at `trait_path`.
+fn write_trait_impl_field_assign<W: std::io::Write>(w: &mut W, trait_path: &str, for_obj: &syn::Ident) {
+ match trait_path {
+ "util::ser::Writeable" => {
+ writeln!(w, "\t\twrite: {}_write_void,", for_obj).unwrap();
+ },
+ _ => unimplemented!(),
+ }
+}
+
+/// Write out the impl block for a defined trait struct which has a supertrait
+fn do_write_impl_trait<W: std::io::Write>(w: &mut W, trait_path: &str, trait_name: &syn::Ident, for_obj: &str) {
+ match trait_path {
+ "util::events::MessageSendEventsProvider" => {
+ writeln!(w, "impl lightning::{} for {} {{", trait_path, for_obj).unwrap();
+ writeln!(w, "\tfn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {{").unwrap();
+ writeln!(w, "\t\t<crate::{} as lightning::{}>::get_and_clear_pending_msg_events(&self.{})", trait_path, trait_path, trait_name).unwrap();
+ writeln!(w, "\t}}\n}}").unwrap();
+ },
+ "util::ser::Writeable" => {
+ writeln!(w, "impl lightning::{} for {} {{", trait_path, for_obj).unwrap();
+ writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {{").unwrap();
+ writeln!(w, "\t\tlet vec = (self.write)(self.this_arg);").unwrap();
+ writeln!(w, "\t\tw.write_all(vec.as_slice())").unwrap();
+ writeln!(w, "\t}}\n}}").unwrap();
+ },
+ _ => panic!(),
+ }
+}
+
// *******************************
// *** Per-Type Printing Logic ***
// *******************************
if supertrait.paren_token.is_some() || supertrait.lifetimes.is_some() {
unimplemented!();
}
- if let Some(ident) = supertrait.path.get_ident() {
- match (&format!("{}", ident) as &str, &ident) {
+ // 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, )*
}
- } else {
- let path = $types.resolve_path(&supertrait.path, None);
- match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) {
+ } else if let Some(ident) = supertrait.path.get_ident() {
+ match (&format!("{}", ident) as &str, &ident) {
$( $pat => $e, )*
}
+ } else {
+ panic!("Supertrait unresolvable and not single-ident");
}
},
syn::TypeParamBound::Lifetime(_) => unimplemented!(),
},
("Send", _) => {}, ("Sync", _) => {},
(s, i) => {
- // For in-crate supertraits, just store a C-mapped copy of the supertrait as a member.
- if types.crate_types.traits.get(s).is_none() { unimplemented!(); }
- writeln!(w, "\tpub {}: crate::{},", i, s).unwrap();
- generated_fields.push(format!("{}", i));
+ generated_fields.push(if types.crate_types.traits.get(s).is_none() {
+ let (name, ret) = convert_trait_impl_field(s);
+ writeln!(w, "\tpub {}: extern \"C\" fn (this_arg: *const c_void) -> {},", name, ret).unwrap();
+ name
+ } else {
+ // For in-crate supertraits, just store a C-mapped copy of the supertrait as a member.
+ writeln!(w, "\tpub {}: crate::{},", i, s).unwrap();
+ format!("{}", i)
+ });
}
) );
writeln!(w, "\tpub free: Option<extern \"C\" fn(this_arg: *mut c_void)>,").unwrap();
writeln!(w, "\t}}\n}}").unwrap();
},
(s, i) => {
- if s != "util::events::MessageSendEventsProvider" { unimplemented!(); }
- // XXX: We straight-up cheat here - instead of bothering to get the trait object we
- // just print what we need since this is only used in one place.
- writeln!(w, "impl lightning::{} for {} {{", s, trait_name).unwrap();
- writeln!(w, "\tfn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {{").unwrap();
- writeln!(w, "\t\t<crate::{} as lightning::{}>::get_and_clear_pending_msg_events(&self.{})", s, s, i).unwrap();
- writeln!(w, "\t}}\n}}").unwrap();
+ do_write_impl_trait(w, s, i, &trait_name);
}
) );
write_cpp_wrapper(cpp_headers, &format!("{}", ident), true);
}
-/// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate
-/// the struct itself, and then writing getters and setters for public, understood-type fields and
-/// a constructor if every field is public.
-fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, types: &mut TypeResolver<'b, 'a>, extra_headers: &mut File, cpp_headers: &mut File) {
- let struct_name = &format!("{}", s.ident);
+fn declare_struct<'a, 'b>(s: &'a syn::ItemStruct, types: &mut TypeResolver<'b, 'a>) -> bool {
let export = export_status(&s.attrs);
match export {
ExportStatus::Export => {},
- ExportStatus::TestOnly => return,
+ ExportStatus::TestOnly => return false,
ExportStatus::NoExport => {
types.struct_ignored(&s.ident);
- return;
+ return false;
}
}
+ types.struct_imported(&s.ident, format!("{}", s.ident));
+ true
+}
+
+/// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate
+/// the struct itself, and then writing getters and setters for public, understood-type fields and
+/// a constructor if every field is public.
+fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, types: &mut TypeResolver<'b, 'a>, extra_headers: &mut File, cpp_headers: &mut File) {
+ if !declare_struct(s, types) { return; }
+
+ let struct_name = &format!("{}", s.ident);
writeln_opaque(w, &s.ident, struct_name, &s.generics, &s.attrs, types, extra_headers, cpp_headers);
eprintln!("exporting fields for {}", struct_name);
writeln!(w, "\t}})), is_owned: true }}\n}}").unwrap();
}
}
-
- types.struct_imported(&s.ident, struct_name.clone());
}
/// Prints a relevant conversion for impl *
ExportStatus::Export => {},
ExportStatus::NoExport|ExportStatus::TestOnly => return,
}
+
+ // For cases where we have a concrete native object which implements a
+ // trait and need to return the C-mapped version of the trait, provide a
+ // From<> implementation which does all the work to ensure free is handled
+ // properly. This way we can call this method from deep in the
+ // type-conversion logic without actually knowing the concrete native type.
+ writeln!(w, "impl From<native{}> for crate::{} {{", ident, full_trait_path).unwrap();
+ writeln!(w, "\tfn from(obj: native{}) -> Self {{", ident).unwrap();
+ writeln!(w, "\t\tlet mut rust_obj = {} {{ inner: Box::into_raw(Box::new(obj)), is_owned: true }};", ident).unwrap();
+ writeln!(w, "\t\tlet mut ret = {}_as_{}(&rust_obj);", ident, trait_obj.ident).unwrap();
+ writeln!(w, "\t\t// We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn").unwrap();
+ writeln!(w, "\t\trust_obj.inner = std::ptr::null_mut();").unwrap();
+ 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();
writeln!(w, "\tcrate::{} {{", full_trait_path).unwrap();
writeln!(w, "\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap();
("Clone", _) => {
writeln!(w, "\t\tclone: Some({}_clone_void),", ident).unwrap();
},
+ ("Sync", _) => {}, ("Send", _) => {},
+ ("std::marker::Sync", _) => {}, ("std::marker::Send", _) => {},
(s, t) => {
- if s.starts_with("util::") {
- let supertrait_obj = types.crate_types.traits.get(s).unwrap();
+ if let Some(supertrait_obj) = types.crate_types.traits.get(s) {
writeln!(w, "\t\t{}: crate::{} {{", t, s).unwrap();
writeln!(w, "\t\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap();
writeln!(w, "\t\t\tfree: None,").unwrap();
}
}
write!(w, "\t\t}},\n").unwrap();
+ } else {
+ write_trait_impl_field_assign(w, s, ident);
}
}
) );
}
walk_supertraits!(trait_obj, types, (
(s, t) => {
- if s.starts_with("util::") {
+ if let Some(supertrait_obj) = types.crate_types.traits.get(s).cloned() {
writeln!(w, "use {}::{} as native{}Trait;", types.orig_crate, s, t).unwrap();
- let supertrait_obj = *types.crate_types.traits.get(s).unwrap();
for item in supertrait_obj.items.iter() {
match item {
syn::TraitItem::Method(m) => {
false
}
+fn declare_enum<'a, 'b>(e: &'a syn::ItemEnum, types: &mut TypeResolver<'b, 'a>) {
+ match export_status(&e.attrs) {
+ ExportStatus::Export => {},
+ ExportStatus::NoExport|ExportStatus::TestOnly => return,
+ }
+
+ if is_enum_opaque(e) {
+ types.enum_ignored(&e.ident);
+ } else {
+ types.mirrored_enum_declared(&e.ident);
+ }
+}
+
/// Print a mapping of an enum. If all of the enum's fields are C-mapped in some form (or the enum
/// is unitary), we generate an equivalent enum with all types replaced with their C mapped
/// versions followed by conversion functions which map between the Rust version and the C mapped
if is_enum_opaque(e) {
eprintln!("Skipping enum {} as it contains non-unit fields", e.ident);
writeln_opaque(w, &e.ident, &format!("{}", e.ident), &e.generics, &e.attrs, types, extra_headers, cpp_headers);
- types.enum_ignored(&e.ident);
return;
}
writeln_docs(w, &e.attrs, "");
if e.generics.lt_token.is_some() {
unimplemented!();
}
- types.mirrored_enum_declared(&e.ident);
let mut needs_free = false;
let mut type_resolver = TypeResolver::new(orig_crate, module, crate_types);
+ // First pass over the items and fill in imports and file-declared objects in the type resolver
for item in syntax.items.iter() {
match item {
syn::Item::Use(u) => type_resolver.process_use(&mut out, &u),
+ syn::Item::Struct(s) => {
+ if let syn::Visibility::Public(_) = s.vis {
+ declare_struct(&s, &mut type_resolver);
+ }
+ },
+ syn::Item::Enum(e) => {
+ if let syn::Visibility::Public(_) = e.vis {
+ declare_enum(&e, &mut type_resolver);
+ }
+ },
+ _ => {},
+ }
+ }
+
+ for item in syntax.items.iter() {
+ match item {
+ syn::Item::Use(_) => {}, // Handled above
syn::Item::Static(_) => {},
syn::Item::Enum(e) => {
if let syn::Visibility::Public(_) = e.vis {