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 ***
writeln!(w, "}}").unwrap();
}
},
- "lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs" => {
+ "lightning::util::ser::Readable"|"lightning::util::ser::ReadableArgs"|"lightning::util::ser::MaybeReadable" => {
// Create the Result<Object, DecodeError> syn::Type
- let res_ty: syn::Type = parse_quote!(Result<#for_ty, ::ln::msgs::DecodeError>);
+ let mut res_ty: syn::Type = parse_quote!(Result<#for_ty, ::ln::msgs::DecodeError>);
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Read a {} from a byte array, created by {}_write", for_obj, for_obj).unwrap();
types.write_from_c_conversion_suffix(&mut arg_conv, &args_ty, Some(generics));
} else { unreachable!(); }
} else { unreachable!(); }
+ } else if t == "lightning::util::ser::MaybeReadable" {
+ res_ty = parse_quote!(Result<Option<#for_ty>, ::ln::msgs::DecodeError>);
}
write!(w, ") -> ").unwrap();
types.write_c_type(w, &res_ty, Some(generics), false);
if t == "lightning::util::ser::ReadableArgs" {
w.write(&arg_conv).unwrap();
- write!(w, ";\n\tlet res: ").unwrap();
- // At least in one case we need type annotations here, so provide them.
- types.write_rust_type(w, Some(generics), &res_ty);
+ write!(w, ";\n").unwrap();
+ }
+
+ write!(w, "\tlet res: ").unwrap();
+ // At least in one case we need type annotations here, so provide them.
+ types.write_rust_type(w, Some(generics), &res_ty);
+
+ if t == "lightning::util::ser::ReadableArgs" {
writeln!(w, " = crate::c_types::deserialize_obj_arg(ser, arg_conv);").unwrap();
+ } else if t == "lightning::util::ser::MaybeReadable" {
+ writeln!(w, " = crate::c_types::maybe_deserialize_obj(ser);").unwrap();
} else {
- writeln!(w, "\tlet res = crate::c_types::deserialize_obj(ser);").unwrap();
+ writeln!(w, " = crate::c_types::deserialize_obj(ser);").unwrap();
}
write!(w, "\t").unwrap();
if types.write_to_c_conversion_new_var(w, &format_ident!("res"), &res_ty, Some(generics), false) {
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();
&syn::TraitItem::Type(ref t) => {
if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); }
let mut bounds_iter = t.bounds.iter();
- match bounds_iter.next().unwrap() {
- syn::TypeParamBound::Trait(tr) => {
- writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap();
- },
- _ => unimplemented!(),
+ loop {
+ match bounds_iter.next().unwrap() {
+ syn::TypeParamBound::Trait(tr) => {
+ writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap();
+ for bound in bounds_iter {
+ if let syn::TypeParamBound::Trait(_) = bound { unimplemented!(); }
+ }
+ break;
+ },
+ syn::TypeParamBound::Lifetime(_) => {},
+ }
}
- if bounds_iter.next().is_some() { unimplemented!(); }
},
_ => unimplemented!(),
}
// 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", _) => {
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();
}
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();
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, $new_name, struct_name).unwrap();
types.write_c_type(w, &ref_type, Some(&gen_types), true);
write!(w, " {{\n\tlet mut inner_val = &mut this_ptr.get_native_mut_ref().{};\n\t", $real_name).unwrap();
- let local_var = types.write_to_c_conversion_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types), true);
+ let local_var = types.write_to_c_conversion_from_ownable_ref_new_var(w, &format_ident!("inner_val"), &ref_type, Some(&gen_types));
if local_var { write!(w, "\n\t").unwrap(); }
types.write_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true);
write!(w, "inner_val").unwrap();
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();
}
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();
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();
}
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();
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)
projects / ldk-c-bindings / blobdiff