mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-24 23:08:36 +01:00
Code Issues Projects Releases Packages Wiki Activity

[bindings] Handle unnamed enum variants

Browse source
This commit is contained in:
Matt Corallo 2021-02-19 13:54:45 -05:00
parent 1d0645f7e6
commit b7538b62d9
2 changed files with 77 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
c-bindings-gen/src/main.rs
View file

@ -1076,6 +1076,17 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
writeln!(w, ",").unwrap();
}
write!(w, "\t}}").unwrap();
} else if let syn::Fields::Unnamed(fields) = &var.fields {
needs_free = true;
write!(w, "(").unwrap();
for (idx, field) in fields.unnamed.iter().enumerate() {
if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
types.write_c_type(w, &field.ty, None, false);
if idx != fields.unnamed.len() - 1 {
write!(w, ",").unwrap();
}
}
write!(w, ")").unwrap();
}
if var.discriminant.is_some() { unimplemented!(); }
writeln!(w, ",").unwrap();
@ -1094,28 +1105,35 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, field.ident.as_ref().unwrap()).unwrap();
}
write!(w, "}} ").unwrap();
} else if let syn::Fields::Unnamed(fields) = &var.fields {
write!(w, "(").unwrap();
for (idx, field) in fields.unnamed.iter().enumerate() {
if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, ('a' as u8 + idx as u8) as char).unwrap();
}
write!(w, ") ").unwrap();
}
write!(w, "=>").unwrap();
if let syn::Fields::Named(fields) = &var.fields {
write!(w, " {{\n\t\t\t\t").unwrap();
for field in fields.named.iter() {
if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
macro_rules! handle_field_a {
($field: expr, $field_ident: expr) => { {
if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
let mut sink = ::std::io::sink();
let mut out: &mut dyn std::io::Write = if $ref { &mut sink } else { w };
let new_var = if $to_c {
types.write_to_c_conversion_new_var(&mut out, field.ident.as_ref().unwrap(), &field.ty, None, false)
types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None, false)
} else {
types.write_from_c_conversion_new_var(&mut out, field.ident.as_ref().unwrap(), &field.ty, None)
types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None)
};
if $ref || new_var {
if $ref {
write!(w, "let mut {}_nonref = (*{}).clone();\n\t\t\t\t", field.ident.as_ref().unwrap(), field.ident.as_ref().unwrap()).unwrap();
write!(w, "let mut {}_nonref = (*{}).clone();\n\t\t\t\t", $field_ident, $field_ident).unwrap();
if new_var {
let nonref_ident = syn::Ident::new(&format!("{}_nonref", field.ident.as_ref().unwrap()), Span::call_site());
let nonref_ident = syn::Ident::new(&format!("{}_nonref", $field_ident), Span::call_site());
if $to_c {
types.write_to_c_conversion_new_var(w, &nonref_ident, &field.ty, None, false);
types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, None, false);
} else {
types.write_from_c_conversion_new_var(w, &nonref_ident, &field.ty, None);
types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, None);
}
write!(w, "\n\t\t\t\t").unwrap();
}
@ -1123,31 +1141,58 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
write!(w, "\n\t\t\t\t").unwrap();
}
}
} }
}
if let syn::Fields::Named(fields) = &var.fields {
write!(w, " {{\n\t\t\t\t").unwrap();
for field in fields.named.iter() {
handle_field_a!(field, field.ident.as_ref().unwrap());
}
} else if let syn::Fields::Unnamed(fields) = &var.fields {
write!(w, " {{\n\t\t\t\t").unwrap();
for (idx, field) in fields.unnamed.iter().enumerate() {
handle_field_a!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
}
} else { write!(w, " ").unwrap(); }
write!(w, "{}{}::{}", if $to_c { "" } else { "native" }, e.ident, var.ident).unwrap();
macro_rules! handle_field_b {
($field: expr, $field_ident: expr) => { {
if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
if $to_c {
types.write_to_c_conversion_inline_prefix(w, &$field.ty, None, false);
} else {
types.write_from_c_conversion_prefix(w, &$field.ty, None);
}
write!(w, "{}{}", $field_ident,
if $ref { "_nonref" } else { "" }).unwrap();
if $to_c {
types.write_to_c_conversion_inline_suffix(w, &$field.ty, None, false);
} else {
types.write_from_c_conversion_suffix(w, &$field.ty, None);
}
write!(w, ",").unwrap();
} }
}
if let syn::Fields::Named(fields) = &var.fields {
write!(w, " {{").unwrap();
for field in fields.named.iter() {
if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
write!(w, "\n\t\t\t\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
if $to_c {
types.write_to_c_conversion_inline_prefix(w, &field.ty, None, false);
} else {
types.write_from_c_conversion_prefix(w, &field.ty, None);
}
write!(w, "{}{}",
field.ident.as_ref().unwrap(),
if $ref { "_nonref" } else { "" }).unwrap();
if $to_c {
types.write_to_c_conversion_inline_suffix(w, &field.ty, None, false);
} else {
types.write_from_c_conversion_suffix(w, &field.ty, None);
}
write!(w, ",").unwrap();
handle_field_b!(field, field.ident.as_ref().unwrap());
}
writeln!(w, "\n\t\t\t\t}}").unwrap();
write!(w, "\t\t\t}}").unwrap();
} else if let syn::Fields::Unnamed(fields) = &var.fields {
write!(w, " (").unwrap();
for (idx, field) in fields.unnamed.iter().enumerate() {
write!(w, "\n\t\t\t\t\t").unwrap();
handle_field_b!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
}
writeln!(w, "\n\t\t\t\t)").unwrap();
write!(w, "\t\t\t}}").unwrap();
}
writeln!(w, ",").unwrap();
}

12
c-bindings-gen/src/types.rs
View file

@ -114,16 +114,20 @@ pub fn assert_simple_bound(bound: &syn::TraitBound) {
/// type), otherwise it is mapped into a transparent, C-compatible version of itself.
pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool {
for var in e.variants.iter() {
if let syn::Fields::Unit = var.fields {
} else if let syn::Fields::Named(fields) = &var.fields {
if let syn::Fields::Named(fields) = &var.fields {
for field in fields.named.iter() {
match export_status(&field.attrs) {
ExportStatus::Export|ExportStatus::TestOnly => {},
ExportStatus::NoExport => return true,
}
}
} else {
return true;
} else if let syn::Fields::Unnamed(fields) = &var.fields {
for field in fields.unnamed.iter() {
match export_status(&field.attrs) {
ExportStatus::Export|ExportStatus::TestOnly => {},
ExportStatus::NoExport => return true,
}
}
}
}
false