}
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 {
for module in super_mod.split("::") {
path.push(syn::PathSegment { ident: syn::Ident::new(module, Span::call_site()), arguments: syn::PathArguments::None });
}
+ } else if partial_path == "" && format!("{}", $ident) == "self" {
+ new_path = format!("{}{}", module_path, $path_suffix);
+ for module in module_path.split("::") {
+ path.push(syn::PathSegment { ident: syn::Ident::new(module, Span::call_site()), arguments: syn::PathArguments::None });
+ }
} else if partial_path == "" && format!("{}", $ident) == "crate" {
new_path = format!("{}{}", crate_name, $path_suffix);
let crate_name_ident = format_ident!("{}", crate_name);
},
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,
}
self.clonable_types.borrow_mut().insert(object);
}
pub fn is_clonable(&self, object: &str) -> bool {
+ object.starts_with("&'static ") ||
self.clonable_types.borrow().contains(object)
}
pub fn write_new_template(&self, mangled_container: String, has_destructor: bool, created_container: &[u8]) {
// *************************************************
/// 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"
"[u8; 32]" if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
"[u8; 20]" if !is_ref => Some("crate::c_types::TwentyBytes"),
"[u8; 16]" if !is_ref => Some("crate::c_types::SixteenBytes"),
- "[u8; 10]" if !is_ref => Some("crate::c_types::TenBytes"),
+ "[u8; 12]" if !is_ref => Some("crate::c_types::TwelveBytes"),
"[u8; 4]" if !is_ref => Some("crate::c_types::FourBytes"),
"[u8; 3]" if !is_ref => Some("crate::c_types::ThreeBytes"), // Used for RGB values
"std::time::Duration"|"core::time::Duration" => Some("u64"),
"std::time::SystemTime" => Some("u64"),
"std::io::Error" => Some("crate::c_types::IOError"),
+ "core::fmt::Arguments" if is_ref => Some("crate::c_types::Str"),
"core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
- "bech32::u5" => Some("crate::c_types::u5"),
+ "bitcoin::bech32::u5"|"bech32::u5" => Some("crate::c_types::u5"),
"core::num::NonZeroU8" => Some("u8"),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
"bitcoin::hash_types::Txid"|"bitcoin::hash_types::BlockHash"|"bitcoin_hashes::sha256::Hash"
if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
"bitcoin::secp256k1::Message" if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if is_ref => Some("*const [u8; 32]"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
- // Override the default since Records contain an fmt with a lifetime:
- "lightning::util::logger::Record" => Some("*const std::os::raw::c_char"),
-
"lightning::io::Read" => Some("crate::c_types::u8slice"),
_ => None,
"[u8; 32]" if !is_ref => Some(""),
"[u8; 20]" if !is_ref => Some(""),
"[u8; 16]" if !is_ref => Some(""),
- "[u8; 10]" if !is_ref => Some(""),
+ "[u8; 12]" if !is_ref => Some(""),
"[u8; 4]" if !is_ref => Some(""),
"[u8; 3]" if !is_ref => Some(""),
"core::convert::Infallible" => Some("panic!(\"You must never construct a NotConstructable! : "),
- "std::time::Duration"|"core::time::Duration" => Some("std::time::Duration::from_secs("),
+ "std::time::Duration"|"core::time::Duration" => Some("core::time::Duration::from_secs("),
"std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("),
- "bech32::u5" => Some(""),
+ "bitcoin::bech32::u5"|"bech32::u5" => Some(""),
"core::num::NonZeroU8" => Some("core::num::NonZeroU8::new("),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
"lightning::ln::PaymentSecret" if !is_ref => Some("::lightning::ln::PaymentSecret("),
"lightning::ln::channelmanager::PaymentId" if !is_ref => Some("::lightning::ln::channelmanager::PaymentId("),
"lightning::ln::channelmanager::PaymentId" if is_ref=> Some("&::lightning::ln::channelmanager::PaymentId( unsafe { *"),
+ "lightning::chain::keysinterface::KeyMaterial" if !is_ref => Some("::lightning::chain::keysinterface::KeyMaterial("),
+ "lightning::chain::keysinterface::KeyMaterial" if is_ref=> Some("&::lightning::chain::keysinterface::KeyMaterial( unsafe { *"),
// List of traits we map (possibly during processing of other files):
- "crate::util::logger::Logger" => Some(""),
-
"lightning::io::Read" => Some("&mut "),
_ => None,
"[u8; 32]" if !is_ref => Some(".data"),
"[u8; 20]" if !is_ref => Some(".data"),
"[u8; 16]" if !is_ref => Some(".data"),
- "[u8; 10]" if !is_ref => Some(".data"),
+ "[u8; 12]" if !is_ref => Some(".data"),
"[u8; 4]" if !is_ref => Some(".data"),
"[u8; 3]" if !is_ref => Some(".data"),
"std::time::Duration"|"core::time::Duration" => Some(")"),
"std::time::SystemTime" => Some("))"),
- "bech32::u5" => Some(".into()"),
+ "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"),
"core::num::NonZeroU8" => Some(").expect(\"Value must be non-zero\")"),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
"bitcoin::hash_types::Txid" if is_ref => Some(" }[..]).unwrap()"),
"bitcoin::hash_types::Txid" => Some(".data[..]).unwrap()"),
"bitcoin::hash_types::BlockHash" if !is_ref => Some(".data[..]).unwrap()"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if !is_ref => Some(".data)"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if is_ref => Some(" })"),
// List of traits we map (possibly during processing of other files):
- "crate::util::logger::Logger" => Some(""),
-
"lightning::io::Read" => Some(".to_reader()"),
_ => None,
"bitcoin::blockdata::block::Block" if is_ref => Some(("::bitcoin::consensus::encode::serialize(", ")")),
"bitcoin::hash_types::Txid" => None,
- // Override the default since Records contain an fmt with a lifetime:
- // TODO: We should include the other record fields
- "lightning::util::logger::Record" => Some(("std::ffi::CString::new(format!(\"{}\", ", ".args)).unwrap()")),
_ => None,
}.map(|s| s.to_owned())
}
"[u8; 32]" if is_ref => Some(""),
"[u8; 20]" if !is_ref => Some("crate::c_types::TwentyBytes { data: "),
"[u8; 16]" if !is_ref => Some("crate::c_types::SixteenBytes { data: "),
- "[u8; 10]" if !is_ref => Some("crate::c_types::TenBytes { data: "),
+ "[u8; 12]" if !is_ref => Some("crate::c_types::TwelveBytes { data: "),
"[u8; 4]" if !is_ref => Some("crate::c_types::FourBytes { data: "),
"[u8; 3]" if is_ref => Some(""),
"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("alloc::format!(\"{}\", "),
"core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
- "bech32::u5" => Some(""),
+ "bitcoin::bech32::u5"|"bech32::u5" => Some(""),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
=> Some("crate::c_types::PublicKey::from_rust(&"),
"bitcoin::hash_types::Txid"|"bitcoin::hash_types::BlockHash"|"bitcoin_hashes::sha256::Hash"
if !is_ref => Some("crate::c_types::ThirtyTwoBytes { data: "),
"bitcoin::secp256k1::Message" if !is_ref => Some("crate::c_types::ThirtyTwoBytes { data: "),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if is_ref => Some("&"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if !is_ref => Some("crate::c_types::ThirtyTwoBytes { data: "),
- // Override the default since Records contain an fmt with a lifetime:
- "lightning::util::logger::Record" => Some("local_"),
-
"lightning::io::Read" => Some("crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec("),
_ => None,
"[u8; 32]" if is_ref => Some(""),
"[u8; 20]" if !is_ref => Some(" }"),
"[u8; 16]" if !is_ref => Some(" }"),
- "[u8; 10]" if !is_ref => Some(" }"),
+ "[u8; 12]" if !is_ref => Some(" }"),
"[u8; 4]" if !is_ref => Some(" }"),
"[u8; 3]" if is_ref => Some(""),
"std::time::Duration"|"core::time::Duration" => Some(".as_secs()"),
"std::time::SystemTime" => Some(".duration_since(::std::time::SystemTime::UNIX_EPOCH).expect(\"Times must be post-1970\").as_secs()"),
"std::io::Error" if !is_ref => Some(")"),
+ "core::fmt::Arguments" => Some(").into()"),
"core::convert::Infallible" => Some("\")"),
- "bech32::u5" => Some(".into()"),
+ "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
=> Some(")"),
"bitcoin::hash_types::Txid"|"bitcoin::hash_types::BlockHash"|"bitcoin_hashes::sha256::Hash"
if !is_ref => Some(".into_inner() }"),
"bitcoin::secp256k1::Message" if !is_ref => Some(".as_ref().clone() }"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if is_ref => Some(".0"),
- "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"|"lightning::ln::channelmanager::PaymentId"
+ "lightning::ln::PaymentHash"|"lightning::ln::PaymentPreimage"|"lightning::ln::PaymentSecret"
+ |"lightning::ln::channelmanager::PaymentId"|"lightning::chain::keysinterface::KeyMaterial"
if !is_ref => Some(".0 }"),
- // Override the default since Records contain an fmt with a lifetime:
- "lightning::util::logger::Record" => Some(".as_ptr()"),
-
"lightning::io::Read" => Some("))"),
_ => None,
/// TODO: We should never need to use this!
fn real_rust_type_mapping<'equiv>(&self, thing: &'equiv str) -> &'equiv str {
match thing {
- "lightning::io::Read" => "std::io::Read",
+ "lightning::io::Read" => "crate::c_types::io::Read",
_ => thing,
}
}
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; }
let is_inner_ref = if let Some(syn::Type::Reference(_)) = single_contained { true } else { false };
if is_ref {
return Some(("if ", vec![
- (".is_none() { std::ptr::null() } else { ObjOps::nonnull_ptr_to_inner(".to_owned(),
+ (".is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner(".to_owned(),
format!("({}{}.unwrap())", var_access, if is_inner_ref { "" } else { ".as_ref()" }))
], ") }", ContainerPrefixLocation::OutsideConv));
} else {
return Some(("if ", vec![
- (".is_none() { std::ptr::null_mut() } else { ".to_owned(), format!("({}.unwrap())", var_access))
+ (".is_none() { core::ptr::null_mut() } else { ".to_owned(), format!("({}.unwrap())", var_access))
], " }", ContainerPrefixLocation::OutsideConv));
}
} else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() {
}
}
if let Some(t) = single_contained {
+ if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = t {
+ assert!(elems.is_empty());
+ let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
+ return Some(("if ", vec![
+ (format!(".is_none() {{ {}::None }} else {{ {}::Some /*",
+ inner_name, inner_name), format!(""))
+ ], " */}", ContainerPrefixLocation::PerConv));
+ }
if let syn::Type::Reference(syn::TypeReference { elem, .. }) = t {
if let syn::Type::Slice(_) = &**elem {
return Some(("if ", vec![
write!(w, ">").unwrap();
}
pub fn write_rust_type<W: std::io::Write>(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type) {
- match t {
+ match generics.resolve_type(t) {
syn::Type::Path(p) => {
if p.qself.is_some() {
unimplemented!();
syn::Type::Path(p) => {
let resolved = self.resolve_path(&p.path, generics);
if self.crate_types.opaques.get(&resolved).is_some() {
- write!(w, "crate::{} {{ inner: std::ptr::null_mut(), is_owned: true }}", resolved).unwrap();
+ write!(w, "crate::{} {{ inner: core::ptr::null_mut(), is_owned: true }}", resolved).unwrap();
} else {
// Assume its a manually-mapped C type, where we can just define an null() fn
write!(w, "{}::null()", self.c_type_from_path(&resolved, false, false).unwrap()).unwrap();
syn::Type::Slice(_) => {
// Option<[]> always implies that we want to treat len() == 0 differently from
// None, so we always map an Option<[]> into a pointer.
- write!(w, " == std::ptr::null_mut()").unwrap();
+ write!(w, " == core::ptr::null_mut()").unwrap();
EmptyValExpectedTy::ReferenceAsPointer
},
_ => unimplemented!(),
// 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;
}
write!(w, "let mut local_{} = (", ident).unwrap();
for (idx, elem) in t.elems.iter().enumerate() {
+ let real_elem = generics.resolve_type(&elem);
let ty_has_inner = {
if to_c {
// "To C ptr_for_ref" means "return the regular object with
// if we're about to set ty_has_inner.
ptr_for_ref = true;
}
- if let syn::Type::Reference(t) = elem {
+ if let syn::Type::Reference(t) = real_elem {
if let syn::Type::Path(p) = &*t.elem {
self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics))
} else { false }
- } else if let syn::Type::Path(p) = elem {
+ } else if let syn::Type::Path(p) = real_elem {
self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics))
} else { false }
};
if idx != 0 { write!(w, ", ").unwrap(); }
- var_prefix(w, elem, generics, is_ref && ty_has_inner, ptr_for_ref, false);
+ var_prefix(w, real_elem, generics, is_ref && ty_has_inner, ptr_for_ref, false);
if is_ref && ty_has_inner {
// For ty_has_inner, the regular var_prefix mapping will take a
// reference, so deref once here to make sure we keep the original ref.
// hope the type is Clonable and use that.
write!(w, ".clone()").unwrap();
}
- var_suffix(w, elem, generics, is_ref && ty_has_inner, ptr_for_ref, false);
+ var_suffix(w, real_elem, generics, is_ref && ty_has_inner, ptr_for_ref, false);
}
write!(w, "){};", if to_c { ".into()" } else { "" }).unwrap();
true
if let syn::Type::Reference(r_arg) = t {
assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners
- if !self.write_c_type_intern(w, &*r_arg.elem, generics, false, false, false, false) { return false; }
+ if !self.write_c_type_intern(w, &*r_arg.elem, generics, false, false, false, true, true) { return false; }
// While write_c_type_intern, above is correct, we don't want to blindly convert a
// reference to something stupid, so check that the container is either opaque or a
} else {
assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners
}
- if !self.write_c_type_intern(w, t, generics, false, false, false, false) { return false; }
+ if !self.write_c_type_intern(w, t, generics, false, false, false, true, true) { return false; }
} else {
- assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners
- if !self.write_c_type_intern(w, t, generics, false, false, false, false) { return false; }
+ // We don't currently support outer reference types for non-primitive inners,
+ // except for the empty tuple.
+ if let syn::Type::Tuple(t_arg) = t {
+ assert!(t_arg.elems.len() == 0 || !is_ref);
+ } else {
+ assert!(!is_ref);
+ }
+ if !self.write_c_type_intern(w, t, generics, false, false, false, true, true) { return false; }
}
}
true
if self.is_transparent_container(ident, is_ref, args.iter().map(|a| *a), generics) {
if !in_type {
if self.c_type_has_inner_from_path(&subtype) {
- if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref, false) { return false; }
+ if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref, false, true) { return false; }
} else {
if let Some(arr_ty) = self.is_real_type_array(&subtype) {
- if !self.write_c_type_intern(w, &arr_ty, generics, false, true, false, false) { return false; }
+ if !self.write_c_type_intern(w, &arr_ty, generics, false, true, false, false, true) { return false; }
} else {
// Option<T> needs to be converted to a *mut T, ie mut ptr-for-ref
- if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false) { return false; }
+ if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false, true) { return false; }
}
}
} else {
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; }
},
// *** C Type Equivalent Printing ***
// **********************************
- fn write_c_path_intern<W: std::io::Write>(&self, w: &mut W, path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool) -> bool {
+ fn write_c_path_intern<W: std::io::Write>(&self, w: &mut W, path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool, c_ty: bool) -> bool {
let full_path = match self.maybe_resolve_path(&path, generics) {
Some(path) => path, None => return false };
if let Some(c_type) = self.c_type_from_path(&full_path, is_ref, ptr_for_ref) {
write!(w, "{}", c_type).unwrap();
true
} else if self.crate_types.traits.get(&full_path).is_some() {
+ // Note that we always use the crate:: prefix here as we are always referring to a
+ // concrete object which is of the generated type, it just implements the upstream
+ // type.
if is_ref && ptr_for_ref {
write!(w, "*{} crate::{}", if is_mut { "mut" } else { "const" }, full_path).unwrap();
} else if is_ref {
}
true
} else if self.crate_types.opaques.get(&full_path).is_some() || self.crate_types.mirrored_enums.get(&full_path).is_some() {
+ let crate_pfx = if c_ty { "crate::" } else { "" };
if is_ref && ptr_for_ref {
// ptr_for_ref implies we're returning the object, which we can't really do for
// opaque or mirrored types without box'ing them, which is quite a waste, so return
// the actual object itself (for opaque types we'll set the pointer to the actual
// type and note that its a reference).
- write!(w, "crate::{}", full_path).unwrap();
+ write!(w, "{}{}", crate_pfx, full_path).unwrap();
} else if is_ref && with_ref_lifetime {
assert!(!is_mut);
// If we're concretizing something with a lifetime parameter, we have to pick a
// lifetime, of which the only real available choice is `static`, obviously.
- write!(w, "&'static ").unwrap();
- self.write_rust_path(w, generics, path);
+ write!(w, "&'static {}", crate_pfx).unwrap();
+ if !c_ty {
+ self.write_rust_path(w, generics, path);
+ } else {
+ write!(w, "{}", full_path).unwrap();
+ }
} else if is_ref {
- write!(w, "&{}crate::{}", if is_mut { "mut " } else { "" }, full_path).unwrap();
+ write!(w, "&{}{}{}", if is_mut { "mut " } else { "" }, crate_pfx, full_path).unwrap();
} else {
- write!(w, "crate::{}", full_path).unwrap();
+ write!(w, "{}{}", crate_pfx, full_path).unwrap();
}
true
} else {
false
}
}
- fn write_c_type_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool) -> bool {
+ fn write_c_type_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool, c_ty: bool) -> bool {
match generics.resolve_type(t) {
syn::Type::Path(p) => {
if p.qself.is_some() {
return self.write_c_mangled_container_path(w, Self::path_to_generic_args(&p.path), generics, &full_path, is_ref, is_mut, ptr_for_ref);
}
if let Some(aliased_type) = self.crate_types.type_aliases.get(&full_path).cloned() {
- return self.write_c_type_intern(w, &aliased_type, None, is_ref, is_mut, ptr_for_ref, with_ref_lifetime);
+ return self.write_c_type_intern(w, &aliased_type, None, is_ref, is_mut, ptr_for_ref, with_ref_lifetime, c_ty);
}
}
- self.write_c_path_intern(w, &p.path, generics, is_ref, is_mut, ptr_for_ref, with_ref_lifetime)
+ self.write_c_path_intern(w, &p.path, generics, is_ref, is_mut, ptr_for_ref, with_ref_lifetime, c_ty)
},
syn::Type::Reference(r) => {
- self.write_c_type_intern(w, &*r.elem, generics, true, r.mutability.is_some(), ptr_for_ref, with_ref_lifetime)
+ self.write_c_type_intern(w, &*r.elem, generics, true, r.mutability.is_some(), ptr_for_ref, with_ref_lifetime, c_ty)
},
syn::Type::Array(a) => {
if is_ref && is_mut {
write!(w, "*mut [").unwrap();
- if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; }
+ if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; }
} else if is_ref {
write!(w, "*const [").unwrap();
- if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; }
+ if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; }
} else {
let mut typecheck = Vec::new();
- if !self.write_c_type_intern(&mut typecheck, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; }
+ if !self.write_c_type_intern(&mut typecheck, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; }
if typecheck[..] != ['u' as u8, '8' as u8] { return false; }
}
if let syn::Expr::Lit(l) = &a.len {
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, c_ty));
+ 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
args.push(syn::GenericArgument::Type((*s.elem).clone()));
let mut segments = syn::punctuated::Punctuated::new();
segments.push(parse_quote!(Vec<#args>));
- self.write_c_type_intern(w, &syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { leading_colon: None, segments } }), generics, false, is_mut, ptr_for_ref, with_ref_lifetime)
+ self.write_c_type_intern(w, &syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { leading_colon: None, segments } }), generics, false, is_mut, ptr_for_ref, with_ref_lifetime, c_ty)
} else { false }
},
syn::Type::Tuple(t) => {
}
}
pub fn write_c_type<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) {
- assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, false));
+ assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, false, true));
}
pub fn write_c_type_in_generic_param<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) {
- assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, true));
+ assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, true, false));
}
pub fn understood_c_path(&self, p: &syn::Path) -> bool {
if p.leading_colon.is_some() { return false; }
- self.write_c_path_intern(&mut std::io::sink(), p, None, false, false, false, false)
+ self.write_c_path_intern(&mut std::io::sink(), p, None, false, false, false, false, true)
}
pub fn understood_c_type(&self, t: &syn::Type, generics: Option<&GenericTypes>) -> bool {
- self.write_c_type_intern(&mut std::io::sink(), t, generics, false, false, false, false)
+ self.write_c_type_intern(&mut std::io::sink(), t, generics, false, false, false, false, true)
}
}
projects / ldk-c-bindings / blobdiff