}
if all_test { return ExportStatus::TestOnly; }
}
- } else if i == "test" || i == "feature" {
- // If its cfg(feature(...)) we assume its test-only
+ } else if i == "test" {
return ExportStatus::TestOnly;
}
}
}
}
-trait ResolveType<'a> { fn resolve_type(&'a self, ty: &'a syn::Type) -> &'a syn::Type; }
+pub trait ResolveType<'a> { fn resolve_type(&'a self, ty: &'a syn::Type) -> &'a syn::Type; }
impl<'a, 'b, 'c: 'a + 'b> ResolveType<'c> for Option<&GenericTypes<'a, 'b>> {
fn resolve_type(&'c self, ty: &'c syn::Type) -> &'c syn::Type {
if let Some(us) = self {
},
syn::Item::Type(t) if export_status(&t.attrs) == ExportStatus::Export => {
if let syn::Visibility::Public(_) = t.vis {
- let mut process_alias = true;
- for tok in t.generics.params.iter() {
- if let syn::GenericParam::Lifetime(_) = tok {}
- else { process_alias = false; }
- }
- if process_alias {
- declared.insert(t.ident.clone(), DeclType::StructImported { generics: &t.generics });
- }
+ declared.insert(t.ident.clone(), DeclType::StructImported { generics: &t.generics });
}
},
syn::Item::Enum(e) => {
let mut res = HashSet::new();
res.insert("crate::c_types::u5".to_owned());
res.insert("crate::c_types::ThirtyTwoBytes".to_owned());
+ res.insert("crate::c_types::SecretKey".to_owned());
res.insert("crate::c_types::PublicKey".to_owned());
res.insert("crate::c_types::Transaction".to_owned());
res.insert("crate::c_types::TxOut".to_owned());
/// This may contain structs or enums, but only when either is mapped as
/// struct X { inner: *mut originalX, .. }
pub opaques: HashMap<String, (&'a syn::Ident, &'a syn::Generics)>,
+ /// structs that weren't exposed
+ pub priv_structs: HashMap<String, &'a syn::Generics>,
/// Enums which are mapped as C enums with conversion functions
pub mirrored_enums: HashMap<String, &'a syn::ItemEnum>,
/// Traits which are mapped as a pointer + jump table
CrateTypes {
opaques: HashMap::new(), mirrored_enums: HashMap::new(), traits: HashMap::new(),
type_aliases: HashMap::new(), reverse_alias_map: HashMap::new(),
- templates_defined: RefCell::new(HashMap::default()),
+ templates_defined: RefCell::new(HashMap::default()), priv_structs: HashMap::new(),
clonable_types: RefCell::new(initial_clonable_types()), trait_impls: HashMap::new(),
template_file: RefCell::new(template_file), lib_ast: &libast,
}
// *************************************************
/// Returns true we if can just skip passing this to C entirely
- fn skip_path(&self, full_path: &str) -> bool {
+ pub fn skip_path(&self, full_path: &str) -> bool {
full_path == "bitcoin::secp256k1::Secp256k1" ||
full_path == "bitcoin::secp256k1::Signing" ||
full_path == "bitcoin::secp256k1::Verification"
"std::time::Duration"|"core::time::Duration" => Some(""),
"std::time::SystemTime" => Some(""),
"std::io::Error" if !is_ref => Some("crate::c_types::IOError::from_rust("),
- "core::fmt::Arguments" => Some("format!(\"{}\", "),
+ "core::fmt::Arguments" => Some("alloc::format!(\"{}\", "),
"core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
assert!(args.next().is_none());
match inner {
syn::Type::Reference(_) => true,
+ syn::Type::Array(a) => {
+ if let syn::Expr::Lit(l) = &a.len {
+ if let syn::Lit::Int(i) = &l.lit {
+ if i.base10_digits().parse::<usize>().unwrap() >= 32 {
+ let mut buf = Vec::new();
+ self.write_rust_type(&mut buf, generics, &a.elem);
+ let ty = String::from_utf8(buf).unwrap();
+ ty == "u8"
+ } else {
+ // Blindly assume that if we're trying to create an empty value for an
+ // array < 32 entries that all-0s may be a valid state.
+ unimplemented!();
+ }
+ } else { unimplemented!(); }
+ } else { unimplemented!(); }
+ },
syn::Type::Path(p) => {
if let Some(resolved) = self.maybe_resolve_path(&p.path, generics) {
if self.c_type_has_inner_from_path(&resolved) { return true; }
// This may result in some outputs not compiling.
if let syn::Type::Path(p) = &*s.elem {
let resolved = self.resolve_path(&p.path, generics);
- assert!(self.is_primitive(&resolved));
- write!(w, "{}", path_lookup("[u8]", is_ref, ptr_for_ref).unwrap()).unwrap();
+ if self.is_primitive(&resolved) {
+ write!(w, "{}", path_lookup("[u8]", is_ref, ptr_for_ref).unwrap()).unwrap();
+ } else {
+ write!(w, "{}", sliceconv(true, None)).unwrap();
+ }
} else if let syn::Type::Reference(r) = &*s.elem {
if let syn::Type::Path(p) = &*r.elem {
write!(w, "{}", sliceconv(self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)), None)).unwrap();
syn::Type::Slice(s) => {
if let syn::Type::Path(p) = &*s.elem {
let resolved = self.resolve_path(&p.path, generics);
- assert!(self.is_primitive(&resolved));
- let slice_path = format!("[{}]", resolved);
- if let Some((prefix, suffix)) = path_lookup(&slice_path, true) {
- write!(w, "let mut local_{} = {}{}{};", ident, prefix, var, suffix).unwrap();
- true
- } else { false }
+ if self.is_primitive(&resolved) {
+ let slice_path = format!("[{}]", resolved);
+ if let Some((prefix, suffix)) = path_lookup(&slice_path, true) {
+ write!(w, "let mut local_{} = {}{}{};", ident, prefix, var, suffix).unwrap();
+ true
+ } else { false }
+ } else {
+ let tyref = [&*s.elem];
+ if to_c {
+ // If we're converting from a slice to a Vec, assume we can clone the
+ // elements and clone them into a new Vec first. Next we'll walk the
+ // new Vec here and convert them to C types.
+ write!(w, "let mut local_{}_clone = Vec::new(); local_{}_clone.extend_from_slice({}); let mut {} = local_{}_clone; ", ident, ident, ident, ident, ident).unwrap();
+ }
+ is_ref = false;
+ convert_container!("Vec", 1, || tyref.iter().map(|t| generics.resolve_type(*t)));
+ unimplemented!("convert_container should return true as container_lookup should succeed for slices");
+ }
} else if let syn::Type::Reference(ty) = &*s.elem {
let tyref = if from_ownable_ref || !to_c { [&*ty.elem] } else { [&*s.elem] };
is_ref = true;
if !self.is_primitive(&resolved) { return false; }
if let syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(len), .. }) = &a.len {
if self.c_type_from_path(&format!("[{}; {}]", resolved, len.base10_digits()), is_ref, ptr_for_ref).is_none() { return false; }
- write!(w, "_{}{}", resolved, len.base10_digits()).unwrap();
- write!(mangled_type, "_{}{}", resolved, len.base10_digits()).unwrap();
+ if in_type || args.len() != 1 {
+ write!(w, "_{}{}", resolved, len.base10_digits()).unwrap();
+ write!(mangled_type, "_{}{}", resolved, len.base10_digits()).unwrap();
+ } else {
+ let arrty = format!("[{}; {}]", resolved, len.base10_digits());
+ let realty = self.c_type_from_path(&arrty, is_ref, ptr_for_ref).unwrap_or(&arrty);
+ write!(w, "{}", realty).unwrap();
+ write!(mangled_type, "{}", realty).unwrap();
+ }
} else { return false; }
} else { return false; }
},
if self.is_primitive(&resolved) {
write!(w, "{}::{}slice", Self::container_templ_path(), resolved).unwrap();
true
- } else { false }
+ } else {
+ let mut inner_c_ty = Vec::new();
+ assert!(self.write_c_path_intern(&mut inner_c_ty, &p.path, generics, true, false, ptr_for_ref, with_ref_lifetime));
+ if self.is_clonable(&String::from_utf8(inner_c_ty).unwrap()) {
+ if let Some(id) = p.path.get_ident() {
+ let mangled_container = format!("CVec_{}Z", id);
+ write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();
+ self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false)
+ } else { false }
+ } else { false }
+ }
} else if let syn::Type::Reference(r) = &*s.elem {
if let syn::Type::Path(p) = &*r.elem {
// Slices with "real types" inside are mapped as the equivalent non-ref Vec
projects / ldk-c-bindings / blobdiff