X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=97f44a4c4c458e22ce017c0b8c53d8524077cea2;hb=76eed6fb43c1d675195aff896efb325828c76498;hp=280f94e9de408af0e367d67234cec85f672a939b;hpb=e63c8846af0e37b6573dd3dde03a2954e1ca3eee;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 280f94e..97f44a4 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -33,7 +33,15 @@ mod blocks;
 use types::*;
 use blocks::*;
 
-const DEFAULT_IMPORTS: &'static str = "\nuse std::str::FromStr;\nuse std::ffi::c_void;\nuse core::convert::Infallible;\nuse bitcoin::hashes::Hash;\nuse crate::c_types::*;\n";
+const DEFAULT_IMPORTS: &'static str = "
+use alloc::str::FromStr;
+use core::ffi::c_void;
+use core::convert::Infallible;
+use bitcoin::hashes::Hash;
+use crate::c_types::*;
+#[cfg(feature=\"no-std\")]
+use alloc::{vec::Vec, boxed::Box};
+";
 
 // *************************************
 // *** Manually-expanded conversions ***
@@ -175,7 +183,7 @@ fn do_write_impl_trait<W: std::io::Write>(w: &mut W, trait_path: &str, _trait_na
 	match trait_path {
 		"lightning::util::ser::Writeable" => {
 			writeln!(w, "impl {} for {} {{", trait_path, for_obj).unwrap();
-			writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {{").unwrap();
+			writeln!(w, "\tfn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {{").unwrap();
 			writeln!(w, "\t\tlet vec = (self.write)(self.this_arg);").unwrap();
 			writeln!(w, "\t\tw.write_all(vec.as_slice())").unwrap();
 			writeln!(w, "\t}}\n}}").unwrap();
@@ -530,13 +538,13 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 	// Implement supertraits for the C-mapped struct.
 	walk_supertraits!(t, Some(&types), (
 		("std::cmp::Eq", _)|("core::cmp::Eq", _) => {
-			writeln!(w, "impl std::cmp::Eq for {} {{}}", trait_name).unwrap();
-			writeln!(w, "impl std::cmp::PartialEq for {} {{", trait_name).unwrap();
+			writeln!(w, "impl core::cmp::Eq for {} {{}}", trait_name).unwrap();
+			writeln!(w, "impl core::cmp::PartialEq for {} {{", trait_name).unwrap();
 			writeln!(w, "\tfn eq(&self, o: &Self) -> bool {{ (self.eq)(self.this_arg, o) }}\n}}").unwrap();
 		},
 		("std::hash::Hash", _)|("core::hash::Hash", _) => {
-			writeln!(w, "impl std::hash::Hash for {} {{", trait_name).unwrap();
-			writeln!(w, "\tfn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap();
+			writeln!(w, "impl core::hash::Hash for {} {{", trait_name).unwrap();
+			writeln!(w, "\tfn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap();
 		},
 		("Send", _) => {}, ("Sync", _) => {},
 		("Clone", _) => {
@@ -582,7 +590,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 		writeln!(w, "}}\n").unwrap();
 		writeln!(w, "// We're essentially a pointer already, or at least a set of pointers, so allow us to be used").unwrap();
 		writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap();
-		writeln!(w, "impl std::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
+		writeln!(w, "impl core::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap();
 		writeln!(w, "\tfn deref(&self) -> &Self {{\n\t\tself\n\t}}\n}}").unwrap();
 	}
 
@@ -642,7 +650,7 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
 	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 = ObjOps::untweak_ptr(self.inner);").unwrap();
-	writeln!(w, "\t\tself.inner = std::ptr::null_mut();").unwrap();
+	writeln!(w, "\t\tself.inner = core::ptr::null_mut();").unwrap();
 	writeln!(w, "\t\tret").unwrap();
 	writeln!(w, "\t}}\n}}").unwrap();
 
@@ -923,7 +931,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 							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();
+							writeln!(w, "\t\trust_obj.inner = core::ptr::null_mut();").unwrap();
 							writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap();
 							writeln!(w, "\t\tret").unwrap();
 						}
@@ -1186,21 +1194,21 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 						let ref_type: syn::Type = syn::parse_quote!(&#path);
 						assert!(!types.write_to_c_conversion_new_var(w, &format_ident!("a"), &*i.self_ty, Some(&gen_types), false), "We don't support new var conversions when comparing equality");
 
-						writeln!(w, "\t// Note that we'd love to use std::collections::hash_map::DefaultHasher but it's not in core").unwrap();
+						writeln!(w, "\t// Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core").unwrap();
 						writeln!(w, "\t#[allow(deprecated)]").unwrap();
 						writeln!(w, "\tlet mut hasher = core::hash::SipHasher::new();").unwrap();
-						write!(w, "\tstd::hash::Hash::hash(").unwrap();
+						write!(w, "\tcore::hash::Hash::hash(").unwrap();
 						types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
 						write!(w, "o").unwrap();
 						types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
 						writeln!(w, ", &mut hasher);").unwrap();
-						writeln!(w, "\tstd::hash::Hasher::finish(&hasher)\n}}").unwrap();
+						writeln!(w, "\tcore::hash::Hasher::finish(&hasher)\n}}").unwrap();
 					} else if (path_matches_nongeneric(&trait_path.1, &["core", "clone", "Clone"]) || path_matches_nongeneric(&trait_path.1, &["Clone"])) &&
 							types.c_type_has_inner_from_path(&resolved_path) {
 						writeln!(w, "impl Clone for {} {{", ident).unwrap();
 						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\tinner: if <*mut native{}>::is_null(self.inner) {{ core::ptr::null_mut() }} else {{", ident).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();
@@ -1639,10 +1647,20 @@ fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: &
 	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();
 	write_method_var_decl_body(w, &f.sig, "", types, Some(&gen_types), false);
-	write!(w, "{}::{}(", types.module_path, f.sig.ident).unwrap();
+	write!(w, "{}::{}", types.module_path, f.sig.ident).unwrap();
+
+	let mut function_generic_args = Vec::new();
+	maybe_write_generics(&mut function_generic_args, &f.sig.generics, types, true);
+	if !function_generic_args.is_empty() {
+		write!(w, "::{}", String::from_utf8(function_generic_args).unwrap()).unwrap();
+	}
+	write!(w, "(").unwrap();
+
 	write_method_call_params(w, &f.sig, "", types, Some(&gen_types), "", false);
 	writeln!(w, "\n}}\n").unwrap();
 }
@@ -1726,6 +1744,12 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &CrateTypes<'a>
 			writeln!(out, "#![allow(unused_braces)]").unwrap();
 			// TODO: We need to map deny(missing_docs) in the source crate(s)
 			//writeln!(out, "#![deny(missing_docs)]").unwrap();
+
+			writeln!(out, "#![cfg_attr(not(feature = \"std\"), no_std)]").unwrap();
+			writeln!(out, "#[cfg(not(any(feature = \"std\", feature = \"no-std\")))]").unwrap();
+			writeln!(out, "compile_error!(\"at least one of the `std` or `no-std` features must be enabled\");").unwrap();
+			writeln!(out, "extern crate alloc;").unwrap();
+
 			writeln!(out, "pub mod version;").unwrap();
 			writeln!(out, "pub mod c_types;").unwrap();
 			writeln!(out, "pub mod bitcoin;").unwrap();
@@ -1972,6 +1996,7 @@ fn main() {
 
 	let mut derived_templates = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
 		.open(&args[2]).expect("Unable to open new header file");
+	writeln!(&mut derived_templates, "{}", DEFAULT_IMPORTS).unwrap();
 	let mut header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
 		.open(&args[3]).expect("Unable to open new header file");
 	let mut cpp_header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)