X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;fp=c-bindings-gen%2Fsrc%2Fmain.rs;h=5905f62f8cf0d111c7e98205cc7bb0c11475abb2;hb=e36b51400fad4173cde525e0378e32e2bbcaa377;hp=f427b5063c5165e90f4a0a92574ac70e1395742f;hpb=0a6c9e85ff86f4b3e814a8286c3c311ade4e0c4a;p=rust-lightning

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index f427b506..5905f62f 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -58,15 +58,27 @@ fn convert_macro<W: std::io::Write>(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: std::io::Write>(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: std::io::Write>(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;
+		if let syn::Type::Path(ref p) = for_ty {
+			if let Some(ident) = p.path.get_ident() {
+				let s = types.maybe_resolve_ident(ident).unwrap();
+				if !types.crate_types.opaques.get(&s).is_some() { return; }
+
+				for_obj = format!("{}", ident);
+				full_obj_path = for_obj.clone();
+			} else { return; }
+		} else {
+			return;
+		}
+
 		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, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, full_obj_path).unwrap();
 				writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap();
 				writeln!(w, "}}").unwrap();
 				writeln!(w, "#[no_mangle]").unwrap();
@@ -75,13 +87,41 @@ fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path
 				writeln!(w, "}}").unwrap();
 			},
 			"util::ser::Readable" => {
+				// Create the Result<Object, DecodeError> 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 +878,12 @@ fn writeln_impl<W: std::io::Write>(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();