// Now that we've resolved the path to the path as-imported, check whether the path
// is actually a pub(.*) use statement and map it to the real path.
let path_tmp = path.clone();
- let crate_name = path_tmp.splitn(1, "::").next().unwrap();
+ let crate_name = path_tmp.splitn(2, "::").next().unwrap();
let mut module_riter = path_tmp.rsplitn(2, "::");
let obj = module_riter.next().unwrap();
if let Some(module_path) = module_riter.next() {
res.insert("crate::c_types::SixteenBytes".to_owned());
res.insert("crate::c_types::TwentyBytes".to_owned());
res.insert("crate::c_types::ThirtyTwoBytes".to_owned());
+ res.insert("crate::c_types::EightU16s".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());
"[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
+ "[u16; 8]" if !is_ref => Some("crate::c_types::EightU16s"),
"str" if is_ref => Some("crate::c_types::Str"),
"alloc::string::String"|"String" => Some("crate::c_types::Str"),
"[u8; 12]" if !is_ref => Some(""),
"[u8; 4]" if !is_ref => Some(""),
"[u8; 3]" if !is_ref => Some(""),
+ "[u16; 8]" if !is_ref => Some(""),
"[u8]" if is_ref => Some(""),
"[usize]" if is_ref => Some(""),
"[u8; 12]" if !is_ref => Some(".data"),
"[u8; 4]" if !is_ref => Some(".data"),
"[u8; 3]" if !is_ref => Some(".data"),
+ "[u16; 8]" if !is_ref => Some(".data"),
"[u8]" if is_ref => Some(".to_slice()"),
"[usize]" if is_ref => Some(".to_slice()"),
"[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(""),
+ "[u16; 8]" if !is_ref => Some("crate::c_types::EightU16s { data: "),
"[u8]" if is_ref => Some("local_"),
"[usize]" if is_ref => Some("local_"),
"[u8; 12]" if !is_ref => Some(" }"),
"[u8; 4]" if !is_ref => Some(" }"),
"[u8; 3]" if is_ref => Some(""),
+ "[u16; 8]" if !is_ref => Some(" }"),
"[u8]" if is_ref => Some(""),
"[usize]" if is_ref => Some(""),
} else { unimplemented!(); }
},
syn::Type::Array(a) => {
- // We assume all arrays contain only [int_literal; X]s.
- // This may result in some outputs not compiling.
- if let syn::Expr::Lit(l) = &a.len {
- if let syn::Lit::Int(i) = &l.lit {
- write!(w, "{}", path_lookup(&format!("[u8; {}]", i.base10_digits()), is_ref, ptr_for_ref).unwrap()).unwrap();
+ if let syn::Type::Path(p) = &*a.elem {
+ let inner_ty = self.resolve_path(&p.path, generics);
+ if let syn::Expr::Lit(l) = &a.len {
+ if let syn::Lit::Int(i) = &l.lit {
+ write!(w, "{}", path_lookup(&format!("[{}; {}]", inner_ty, i.base10_digits()), is_ref, ptr_for_ref).unwrap()).unwrap();
+ } else { unimplemented!(); }
} else { unimplemented!(); }
} else { unimplemented!(); }
},
write!(w, "let mut local_{}{} = ", ident,
if (!to_c && needs_ref_map) || (to_c && $container_type == "Option" && contains_slice) {"_base"} else { "" }).unwrap();
if prefix_location == ContainerPrefixLocation::OutsideConv {
- var_prefix(w, $args_iter().next().unwrap(), generics, is_ref, ptr_for_ref, true);
+ var_prefix(w, $args_iter().next().unwrap(), generics, is_ref, true, true);
}
write!(w, "{}{}", prefix, var).unwrap();
if let syn::Type::Path(p) = &*refelem.elem {
write_path!(p, Some(&mut mangled_tuple_type));
} else { return false; }
+ } else if let syn::Type::Array(_) = elem {
+ let mut resolved = Vec::new();
+ if !self.write_c_type_intern(&mut resolved, &elem, generics, false, false, true, false, true) { return false; }
+ let array_inner = String::from_utf8(resolved).unwrap();
+ let arr_name = array_inner.split("::").last().unwrap();
+ write!(w, "{}", arr_name).unwrap();
+ write!(mangled_type, "{}", arr_name).unwrap();
} else { return false; }
}
write!(w, "Z").unwrap();
} 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, 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, c_ty) { return false; }
- if typecheck[..] != ['u' as u8, '8' as u8] { return false; }
}
if let syn::Expr::Lit(l) = &a.len {
if let syn::Lit::Int(i) = &l.lit {
+ let mut inner_ty = Vec::new();
+ if !self.write_c_type_intern(&mut inner_ty, &*a.elem, generics, false, false, ptr_for_ref, false, c_ty) { return false; }
+ let inner_ty_str = String::from_utf8(inner_ty).unwrap();
if !is_ref {
- if let Some(ty) = self.c_type_from_path(&format!("[u8; {}]", i.base10_digits()), false, ptr_for_ref) {
+ if let Some(ty) = self.c_type_from_path(&format!("[{}; {}]", inner_ty_str, i.base10_digits()), false, ptr_for_ref) {
write!(w, "{}", ty).unwrap();
true
} else { false }