X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=c197839c9249a3443396ff90159280f4c5a4857f;hb=4fe9aea4b8a07a5a95ebeca448c66ef8b9cc5c94;hp=f427b5063c5165e90f4a0a92574ac70e1395742f;hpb=9e02d0a1e07f3a258ce6e7769a4968e3bb4f423d;p=rust-lightning diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index f427b5063..c197839c9 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -58,30 +58,88 @@ fn convert_macro(w: &mut W, macro_path: &syn::Path, stream: & } } -/// Convert "impl trait_path for for_obj { .. }" for manually-mapped types (ie (de)serialization) -fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path, for_obj: &syn::Ident, types: &TypeResolver) { +/// Convert "impl trait_path for for_ty { .. }" for manually-mapped types (ie (de)serialization) +fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path, for_ty: &syn::Type, types: &mut TypeResolver) { if let Some(t) = types.maybe_resolve_path(&trait_path, None) { - let s = types.maybe_resolve_ident(for_obj).unwrap(); - if !types.crate_types.opaques.get(&s).is_some() { return; } + let for_obj; + 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() { + for_obj = format!("{}", ident); + full_obj_path = for_obj.clone(); + has_inner = types.c_type_has_inner_from_path(&types.resolve_path(&p.path, None)); + } else { return; } + } else { + // We assume that anything that isn't a Path is somehow a generic that ends up in our + // derived-types module. + let mut for_obj_vec = Vec::new(); + types.write_c_type(&mut for_obj_vec, for_ty, None, false); + full_obj_path = String::from_utf8(for_obj_vec).unwrap(); + assert!(full_obj_path.starts_with(TypeResolver::generated_container_path())); + for_obj = full_obj_path[TypeResolver::generated_container_path().len() + 2..].into(); + } + 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, 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, "pub extern \"C\" fn {}_write(obj: *const {}) -> 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, + elem: Box::new(for_ty.clone()) }); + assert!(!types.write_from_c_conversion_new_var(w, &syn::Ident::new("obj", Span::call_site()), &ref_type, None)); + + write!(w, "\tcrate::c_types::serialize_obj(").unwrap(); + types.write_from_c_conversion_prefix(w, &ref_type, None); + write!(w, "unsafe {{ &*obj }}").unwrap(); + types.write_from_c_conversion_suffix(w, &ref_type, None); + writeln!(w, ")").unwrap(); + writeln!(w, "}}").unwrap(); + if has_inner { + 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" => { + // Create the Result syn::Type + let mut err_segs = syn::punctuated::Punctuated::new(); + err_segs.push(syn::PathSegment { ident: syn::Ident::new("ln", Span::call_site()), arguments: syn::PathArguments::None }); + err_segs.push(syn::PathSegment { ident: syn::Ident::new("msgs", Span::call_site()), arguments: syn::PathArguments::None }); + err_segs.push(syn::PathSegment { ident: syn::Ident::new("DecodeError", Span::call_site()), arguments: syn::PathArguments::None }); + let mut args = syn::punctuated::Punctuated::new(); + args.push(syn::GenericArgument::Type(for_ty.clone())); + args.push(syn::GenericArgument::Type(syn::Type::Path(syn::TypePath { + qself: None, path: syn::Path { + leading_colon: Some(syn::Token![::](Span::call_site())), segments: err_segs, + } + }))); + let mut res_segs = syn::punctuated::Punctuated::new(); + res_segs.push(syn::PathSegment { + ident: syn::Ident::new("Result", Span::call_site()), + arguments: syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments { + colon2_token: None, lt_token: syn::Token![<](Span::call_site()), args, gt_token: syn::Token![>](Span::call_site()), + }) + }); + let res_ty = syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { + leading_colon: None, segments: res_segs } }); + writeln!(w, "#[no_mangle]").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice) -> {} {{", for_obj, for_obj).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 }}", for_obj).unwrap(); - writeln!(w, "\t}} else {{").unwrap(); - writeln!(w, "\t\t{} {{ inner: std::ptr::null_mut(), is_owned: true }}", for_obj).unwrap(); - writeln!(w, "\t}}\n}}").unwrap(); + write!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice) -> ", for_obj).unwrap(); + types.write_c_type(w, &res_ty, None, false); + writeln!(w, " {{").unwrap(); + writeln!(w, "\tlet res = crate::c_types::deserialize_obj(ser);").unwrap(); + write!(w, "\t").unwrap(); + if types.write_to_c_conversion_new_var(w, &syn::Ident::new("res", Span::call_site()), &res_ty, None, false) { + write!(w, "\n\t").unwrap(); + } + types.write_to_c_conversion_inline_prefix(w, &res_ty, None, false); + write!(w, "res").unwrap(); + types.write_to_c_conversion_inline_suffix(w, &res_ty, None, false); + writeln!(w, "\n}}").unwrap(); }, _ => {}, } @@ -838,12 +896,12 @@ 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, &ident, types), + _ if p.path.get_ident().is_some() => maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types), _ => {}, } } else if p.path.get_ident().is_some() { // If we have no generics, try a manual implementation: - maybe_convert_trait_impl(w, &trait_path.1, &ident, types); + maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types); } } else { let declared_type = (*types.get_declared_type(&ident).unwrap()).clone();