X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=ce69294928af16714f3e7b645d34cbc2faa9f510;hp=4c14074143966fe89b0f54c6979c5889ca4e87dc;hb=ed6eb46f7b4e0d4c869ad08dffc600b4e93e2129;hpb=d7a6aee121ef6089376b0c856e11c4b1d70521b6 diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index 4c14074..ce69294 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) => { @@ -256,7 +258,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty let mut meth_gen_types = gen_types.push_ctx(); assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); - writeln_docs(w, &m.attrs, "\t"); + writeln_fn_docs(w, &m.attrs, "\t", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output); if let syn::ReturnType::Type(_, rtype) = &m.sig.output { if let syn::Type::Reference(r) = &**rtype { @@ -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_fn_docs(&mut cpp_docs, &m.attrs, "\t * ", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output); + 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 @@ -550,7 +563,7 @@ fn writeln_opaque(w: &mut W, ident: &syn::Ident, struct_name: writeln!(w, "}}\n").unwrap(); writeln!(w, "impl Drop for {} {{\n\tfn drop(&mut self) {{", struct_name).unwrap(); writeln!(w, "\t\tif self.is_owned && !<*mut native{}>::is_null(self.inner) {{", ident).unwrap(); - writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(self.inner) }};\n\t\t}}\n\t}}\n}}").unwrap(); + writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(ObjOps::untweak_ptr(self.inner)) }};\n\t\t}}\n\t}}\n}}").unwrap(); writeln!(w, "/// Frees any resources used by the {}, if is_owned is set and inner is non-NULL.", struct_name).unwrap(); writeln!(w, "#[no_mangle]\npub extern \"C\" fn {}_free(this_obj: {}) {{ }}", struct_name, struct_name).unwrap(); writeln!(w, "#[allow(unused)]").unwrap(); @@ -558,16 +571,22 @@ fn writeln_opaque(w: &mut W, ident: &syn::Ident, struct_name: writeln!(w, "extern \"C\" fn {}_free_void(this_ptr: *mut c_void) {{", struct_name).unwrap(); writeln!(w, "\tunsafe {{ let _ = Box::from_raw(this_ptr as *mut native{}); }}\n}}", struct_name).unwrap(); writeln!(w, "#[allow(unused)]").unwrap(); - writeln!(w, "/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy").unwrap(); writeln!(w, "impl {} {{", struct_name).unwrap(); + writeln!(w, "\tpub(crate) fn get_native_ref(&self) -> &'static native{} {{", struct_name).unwrap(); + writeln!(w, "\t\tunsafe {{ &*ObjOps::untweak_ptr(self.inner) }}").unwrap(); + writeln!(w, "\t}}").unwrap(); + writeln!(w, "\tpub(crate) fn get_native_mut_ref(&self) -> &'static mut native{} {{", struct_name).unwrap(); + writeln!(w, "\t\tunsafe {{ &mut *ObjOps::untweak_ptr(self.inner) }}").unwrap(); + writeln!(w, "\t}}").unwrap(); + writeln!(w, "\t/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy").unwrap(); writeln!(w, "\tpub(crate) fn take_inner(mut self) -> *mut native{} {{", struct_name).unwrap(); writeln!(w, "\t\tassert!(self.is_owned);").unwrap(); - writeln!(w, "\t\tlet ret = self.inner;").unwrap(); + writeln!(w, "\t\tlet ret = ObjOps::untweak_ptr(self.inner);").unwrap(); writeln!(w, "\t\tself.inner = std::ptr::null_mut();").unwrap(); 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 @@ -604,10 +623,10 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None, elem: Box::new(field.ty.clone()) }); if types.understood_c_type(&ref_type, Some(&gen_types)) { - writeln_docs(w, &field.attrs, ""); + writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![].drain(..), Some(&ref_type)); write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, ident, struct_name).unwrap(); types.write_c_type(w, &ref_type, Some(&gen_types), true); - write!(w, " {{\n\tlet mut inner_val = &mut unsafe {{ &mut *this_ptr.inner }}.{};\n\t", ident).unwrap(); + write!(w, " {{\n\tlet mut inner_val = &mut this_ptr.get_native_mut_ref().{};\n\t", ident).unwrap(); let local_var = types.write_to_c_conversion_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types), true); if local_var { write!(w, "\n\t").unwrap(); } types.write_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true); @@ -617,13 +636,13 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, } if types.understood_c_type(&field.ty, Some(&gen_types)) { - writeln_docs(w, &field.attrs, ""); + writeln_arg_docs(w, &field.attrs, "", types, Some(&gen_types), vec![("val".to_owned(), &field.ty)].drain(..), None); write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: &mut {}, mut val: ", struct_name, ident, struct_name).unwrap(); types.write_c_type(w, &field.ty, Some(&gen_types), false); write!(w, ") {{\n\t").unwrap(); let local_var = types.write_from_c_conversion_new_var(w, &format_ident!("val"), &field.ty, Some(&gen_types)); if local_var { write!(w, "\n\t").unwrap(); } - write!(w, "unsafe {{ &mut *this_ptr.inner }}.{} = ", ident).unwrap(); + write!(w, "unsafe {{ &mut *ObjOps::untweak_ptr(this_ptr.inner) }}.{} = ", ident).unwrap(); types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types)); write!(w, "val").unwrap(); types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types)); @@ -649,7 +668,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, write!(w, "\n\t").unwrap(); } } - writeln!(w, "{} {{ inner: Box::into_raw(Box::new(native{} {{", struct_name, s.ident).unwrap(); + writeln!(w, "{} {{ inner: ObjOps::heap_alloc(native{} {{", struct_name, s.ident).unwrap(); for field in fields.named.iter() { write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap(); types.write_from_c_conversion_prefix(w, &field.ty, Some(&gen_types)); @@ -657,7 +676,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, types.write_from_c_conversion_suffix(w, &field.ty, Some(&gen_types)); writeln!(w, ",").unwrap(); } - writeln!(w, "\t}})), is_owned: true }}\n}}").unwrap(); + writeln!(w, "\t}}), is_owned: true }}\n}}").unwrap(); } } } @@ -751,7 +770,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ // type-conversion logic without actually knowing the concrete native type. writeln!(w, "impl From 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 rust_obj = {} {{ inner: ObjOps::heap_alloc(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(); @@ -762,7 +781,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "/// This copies the `inner` pointer in this_arg and thus the returned {} must be freed before this_arg is", trait_obj.ident).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\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap(); writeln!(w, "\t\tfree: None,").unwrap(); macro_rules! write_meth { @@ -813,7 +832,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ (s, t) => { 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\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap(); writeln!(w, "\t\t\tfree: None,").unwrap(); for item in supertrait_obj.items.iter() { match item { @@ -928,7 +947,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ } else if path_matches_nongeneric(&trait_path.1, &["Default"]) { writeln!(w, "/// Creates a \"default\" {}. See struct and individual field documentaiton for details on which values are used.", ident).unwrap(); write!(w, "#[must_use]\n#[no_mangle]\npub extern \"C\" fn {}_default() -> {} {{\n", ident, ident).unwrap(); - write!(w, "\t{} {{ inner: Box::into_raw(Box::new(Default::default())), is_owned: true }}\n", ident).unwrap(); + write!(w, "\t{} {{ inner: ObjOps::heap_alloc(Default::default()), is_owned: true }}\n", ident).unwrap(); write!(w, "}}\n").unwrap(); } else if path_matches_nongeneric(&trait_path.1, &["core", "cmp", "PartialEq"]) { } else if path_matches_nongeneric(&trait_path.1, &["core", "cmp", "Eq"]) { @@ -983,7 +1002,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); writeln!(w, "\t\tSelf {{").unwrap(); writeln!(w, "\t\t\tinner: if <*mut native{}>::is_null(self.inner) {{ std::ptr::null_mut() }} else {{", ident).unwrap(); - writeln!(w, "\t\t\t\tBox::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())) }},").unwrap(); + writeln!(w, "\t\t\t\tObjOps::heap_alloc(unsafe {{ &*ObjOps::untweak_ptr(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(); @@ -1045,8 +1064,10 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ ExportStatus::NoExport|ExportStatus::TestOnly => continue, ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"), } + let mut meth_gen_types = gen_types.push_ctx(); + assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); if m.defaultness.is_some() { unimplemented!(); } - writeln_docs(w, &m.attrs, ""); + writeln_fn_docs(w, &m.attrs, "", types, Some(&meth_gen_types), m.sig.inputs.iter(), &m.sig.output); if let syn::ReturnType::Type(_, _) = &m.sig.output { writeln!(w, "#[must_use]").unwrap(); } @@ -1056,8 +1077,6 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ DeclType::StructImported => format!("{}", ident), _ => unimplemented!(), }; - let mut meth_gen_types = gen_types.push_ctx(); - assert!(meth_gen_types.learn_generics(&m.sig.generics, types)); write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true); write!(w, " {{\n\t").unwrap(); write_method_var_decl_body(w, &m.sig, "", types, Some(&meth_gen_types), false); @@ -1080,9 +1099,9 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ if takes_owned_self { write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap(); } else if takes_mut_self { - write!(w, "unsafe {{ &mut (*(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap(); + write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap(); } else { - write!(w, "unsafe {{ &*this_arg.inner }}.{}(", m.sig.ident).unwrap(); + write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap(); } }, _ => unimplemented!(), @@ -1157,6 +1176,23 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ } } +/// Replaces upper case charachters with underscore followed by lower case except the first +/// charachter and repeated upper case characthers (which are only made lower case). +fn camel_to_snake_case(camel: &str) -> String { + let mut res = "".to_string(); + let mut last_upper = -1; + for (idx, c) in camel.chars().enumerate() { + if c.is_uppercase() { + if last_upper != idx as isize - 1 { res.push('_'); } + res.push(c.to_lowercase().next().unwrap()); + last_upper = idx as isize; + } else { + res.push(c); + } + } + res +} + /// 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 @@ -1180,25 +1216,31 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type assert!(gen_types.learn_generics(&e.generics, types)); let mut needs_free = false; + let mut constr = Vec::new(); writeln!(w, "#[must_use]\n#[derive(Clone)]\n#[repr(C)]\npub enum {} {{", e.ident).unwrap(); for var in e.variants.iter() { assert_eq!(export_status(&var.attrs), ExportStatus::Export); // We can't partially-export a mirrored enum writeln_docs(w, &var.attrs, "\t"); write!(w, "\t{}", var.ident).unwrap(); + writeln!(&mut constr, "#[no_mangle]\n/// Utility method to constructs a new {}-variant {}", var.ident, e.ident).unwrap(); + let constr_name = camel_to_snake_case(&format!("{}", var.ident)); + write!(&mut constr, "pub extern \"C\" fn {}_{}(", e.ident, constr_name).unwrap(); + let mut empty_tuple_variant = false; if let syn::Fields::Named(fields) = &var.fields { needs_free = true; writeln!(w, " {{").unwrap(); - for field in fields.named.iter() { + for (idx, field) in fields.named.iter().enumerate() { if export_status(&field.attrs) == ExportStatus::TestOnly { continue; } - writeln_docs(w, &field.attrs, "\t\t"); + writeln_field_docs(w, &field.attrs, "\t\t", types, Some(&gen_types), &field.ty); write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap(); + write!(&mut constr, "{}{}: ", if idx != 0 { ", " } else { "" }, field.ident.as_ref().unwrap()).unwrap(); types.write_c_type(w, &field.ty, Some(&gen_types), false); + types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false); writeln!(w, ",").unwrap(); } write!(w, "\t}}").unwrap(); } else if let syn::Fields::Unnamed(fields) = &var.fields { - let mut empty_tuple_variant = false; if fields.unnamed.len() == 1 { let mut empty_check = Vec::new(); types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false); @@ -1211,15 +1253,37 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type write!(w, "(").unwrap(); for (idx, field) in fields.unnamed.iter().enumerate() { if export_status(&field.attrs) == ExportStatus::TestOnly { continue; } + write!(&mut constr, "{}: ", ('a' as u8 + idx as u8) as char).unwrap(); types.write_c_type(w, &field.ty, Some(&gen_types), false); + types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false); if idx != fields.unnamed.len() - 1 { write!(w, ",").unwrap(); + write!(&mut constr, ",").unwrap(); } } write!(w, ")").unwrap(); } } if var.discriminant.is_some() { unimplemented!(); } + write!(&mut constr, ") -> {} {{\n\t{}::{}", e.ident, e.ident, var.ident).unwrap(); + if let syn::Fields::Named(fields) = &var.fields { + writeln!(&mut constr, " {{").unwrap(); + for field in fields.named.iter() { + writeln!(&mut constr, "\t\t{},", field.ident.as_ref().unwrap()).unwrap(); + } + writeln!(&mut constr, "\t}}").unwrap(); + } else if let syn::Fields::Unnamed(fields) = &var.fields { + if !empty_tuple_variant { + write!(&mut constr, "(").unwrap(); + for idx in 0..fields.unnamed.len() { + write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap(); + } + writeln!(&mut constr, ")").unwrap(); + } else { + writeln!(&mut constr, "").unwrap(); + } + } + writeln!(&mut constr, "}}").unwrap(); writeln!(w, ",").unwrap(); } writeln!(w, "}}\nuse {}::{} as native{};\nimpl {} {{", types.module_path, e.ident, e.ident, e.ident).unwrap(); @@ -1360,7 +1424,8 @@ 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); + w.write_all(&constr).unwrap(); + 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>) { @@ -1369,11 +1434,11 @@ fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: & ExportStatus::NoExport|ExportStatus::TestOnly => return, ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"), } - writeln_docs(w, &f.attrs, ""); - let mut gen_types = GenericTypes::new(None); if !gen_types.learn_generics(&f.sig.generics, types) { return; } + writeln_fn_docs(w, &f.attrs, "", types, Some(&gen_types), f.sig.inputs.iter(), &f.sig.output); + write!(w, "#[no_mangle]\npub extern \"C\" fn {}(", f.sig.ident).unwrap(); write_method_params(w, &f.sig, "", types, Some(&gen_types), false, true); write!(w, " {{\n\t").unwrap(); @@ -1509,7 +1574,7 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a> if let syn::Type::Path(p) = &*c.ty { let resolved_path = type_resolver.resolve_path(&p.path, None); if type_resolver.is_primitive(&resolved_path) { - writeln_docs(&mut out, &c.attrs, ""); + writeln_field_docs(&mut out, &c.attrs, "", &mut type_resolver, None, &*c.ty); writeln!(out, "\n#[no_mangle]").unwrap(); writeln!(out, "pub static {}: {} = {}::{};", c.ident, resolved_path, module, c.ident).unwrap(); } @@ -1744,7 +1809,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();