X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=2f94e432e4f351c36e8f975cb531d1d57258f7ba;hb=036da10cc98c0d3ca093a58a9cd9f20dcba832c7;hp=c8adf7df1b6e7238c0a907c8aa4662019dc3b70b;hpb=75e8cf5acf256d8ecaf0c68e60997f6423e83c04;p=ldk-c-bindings diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index c8adf7d..2f94e43 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -258,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 { @@ -293,7 +293,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty } let mut cpp_docs = Vec::new(); - writeln_docs(&mut cpp_docs, &m.attrs, "\t * "); + 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(); @@ -617,7 +617,7 @@ 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(); @@ -630,7 +630,7 @@ 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(); @@ -1058,8 +1058,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(); } @@ -1069,8 +1071,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); @@ -1170,6 +1170,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 @@ -1193,25 +1210,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); @@ -1224,15 +1247,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(); @@ -1373,6 +1418,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(); + w.write_all(&constr).unwrap(); write_cpp_wrapper(cpp_headers, &format!("{}", e.ident), needs_free, None); } @@ -1382,11 +1428,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(); @@ -1522,7 +1568,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(); }