X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=f427b5063c5165e90f4a0a92574ac70e1395742f;hb=7797d7c3c2d237ca8cbd31ba9a4611f80f647776;hp=6d6296c8f48e93dc661924cf08c239694c74896b;hpb=52e55d4570e58b96d142a77f26efa81347d11ba1;p=rust-lightning

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 6d6296c8f..f427b5063 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -454,7 +454,7 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
 	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 take_ptr(mut self) -> *mut native{} {{", struct_name).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\tself.inner = std::ptr::null_mut();").unwrap();
@@ -500,21 +500,28 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_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);
@@ -598,8 +605,6 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct,
 			writeln!(w, "\t}})), is_owned: true }}\n}}").unwrap();
 		}
 	}
-
-	types.struct_imported(&s.ident, struct_name.clone());
 }
 
 /// Prints a relevant conversion for impl *
@@ -916,6 +921,19 @@ fn is_enum_opaque(e: &syn::ItemEnum) -> bool {
 	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
@@ -929,7 +947,6 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 	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, "");
@@ -937,7 +954,6 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 	if e.generics.lt_token.is_some() {
 		unimplemented!();
 	}
-	types.mirrored_enum_declared(&e.ident);
 
 	let mut needs_free = false;
 
@@ -1166,9 +1182,27 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &mut CrateTypes
 
 	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 {