}
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;
}
}
// *************************************************
/// 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; }
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; }
},