X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fblocks.rs;h=84a971bd43405dbfa877d60762f5c4e24d68cd58;hb=HEAD;hp=e48a98a5c5a14787f489096eabd8d283267d33ec;hpb=18dc4eff64fcad567e67dfe11c501a9b4ec7633e;p=ldk-c-bindings diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index e48a98a..dc160d2 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -61,7 +61,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\tpub result: *mut {},", ok_type).unwrap(); } else { writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the OK variant").unwrap(); - writeln!(w, "\tpub result: *mut std::ffi::c_void,").unwrap(); + writeln!(w, "\tpub result: *mut core::ffi::c_void,").unwrap(); } if err_type != "()" { writeln!(w, "\t/// A pointer to the contents in the error state.").unwrap(); @@ -69,7 +69,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\tpub err: *mut {},", err_type).unwrap(); } else { writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the Err variant").unwrap(); - writeln!(w, "\tpub err: *mut std::ffi::c_void,").unwrap(); + writeln!(w, "\tpub err: *mut core::ffi::c_void,").unwrap(); } writeln!(w, "}}").unwrap(); writeln!(w, "#[repr(C)]").unwrap(); @@ -97,7 +97,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if ok_type != "()" { writeln!(w, "\t\t\tresult: Box::into_raw(Box::new(o)),").unwrap(); } else { - writeln!(w, "\t\t\tresult: std::ptr::null_mut(),").unwrap(); + writeln!(w, "\t\t\tresult: core::ptr::null_mut(),").unwrap(); } writeln!(w, "\t\t}},").unwrap(); writeln!(w, "\t\tresult_ok: true,").unwrap(); @@ -117,13 +117,19 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if err_type != "()" { writeln!(w, "\t\t\terr: Box::into_raw(Box::new(e)),").unwrap(); } else { - writeln!(w, "\t\t\terr: std::ptr::null_mut(),").unwrap(); + writeln!(w, "\t\t\terr: core::ptr::null_mut(),").unwrap(); } writeln!(w, "\t\t}},").unwrap(); writeln!(w, "\t\tresult_ok: false,").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); + writeln!(w, "/// Checks if the given object is currently in the success state").unwrap(); + writeln!(w, "#[no_mangle]").unwrap(); + writeln!(w, "pub extern \"C\" fn {}_is_ok(o: &{}) -> bool {{", mangled_container, mangled_container).unwrap(); + writeln!(w, "\to.result_ok").unwrap(); + writeln!(w, "}}").unwrap(); + writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Frees any resources used by the {}.", mangled_container).unwrap(); writeln!(w, "pub extern \"C\" fn {}_free(_res: {}) {{ }}", mangled_container, mangled_container).unwrap(); @@ -150,22 +156,22 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\t\tlet contents = if o.result_ok {{").unwrap(); if ok_type != "()" { writeln!(w, "\t\t\tlet result = unsafe {{ o.contents.result }};").unwrap(); - writeln!(w, "\t\t\tunsafe {{ o.contents.result = std::ptr::null_mut() }};").unwrap(); + writeln!(w, "\t\t\tunsafe {{ o.contents.result = core::ptr::null_mut() }};").unwrap(); writeln!(w, "\t\t\t{}Ptr {{ result }}", mangled_container).unwrap(); } else { writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.result) }};").unwrap(); - writeln!(w, "\t\t\to.contents.result = std::ptr::null_mut();").unwrap(); - writeln!(w, "\t\t\t{}Ptr {{ result: std::ptr::null_mut() }}", mangled_container).unwrap(); + writeln!(w, "\t\t\to.contents.result = core::ptr::null_mut();").unwrap(); + writeln!(w, "\t\t\t{}Ptr {{ result: core::ptr::null_mut() }}", mangled_container).unwrap(); } writeln!(w, "\t\t}} else {{").unwrap(); if err_type != "()" { writeln!(w, "\t\t\tlet err = unsafe {{ o.contents.err }};").unwrap(); - writeln!(w, "\t\t\tunsafe {{ o.contents.err = std::ptr::null_mut(); }}").unwrap(); + writeln!(w, "\t\t\tunsafe {{ o.contents.err = core::ptr::null_mut(); }}").unwrap(); writeln!(w, "\t\t\t{}Ptr {{ err }}", mangled_container).unwrap(); } else { writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.err) }};").unwrap(); - writeln!(w, "\t\t\to.contents.err = std::ptr::null_mut();").unwrap(); - writeln!(w, "\t\t\t{}Ptr {{ err: std::ptr::null_mut() }}", mangled_container).unwrap(); + writeln!(w, "\t\t\to.contents.err = core::ptr::null_mut();").unwrap(); + writeln!(w, "\t\t\t{}Ptr {{ err: core::ptr::null_mut() }}", mangled_container).unwrap(); } writeln!(w, "\t\t}};").unwrap(); writeln!(w, "\t\tSelf {{").unwrap(); @@ -183,7 +189,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if ok_type != "()" { writeln!(w, "\t\t\t\tresult: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.result }})))", ok_type).unwrap(); } else { - writeln!(w, "\t\t\t\tresult: std::ptr::null_mut()").unwrap(); + writeln!(w, "\t\t\t\tresult: core::ptr::null_mut()").unwrap(); } writeln!(w, "\t\t\t}} }}").unwrap(); writeln!(w, "\t\t}} else {{").unwrap(); @@ -191,7 +197,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if err_type != "()" { writeln!(w, "\t\t\t\terr: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.err }})))", err_type).unwrap(); } else { - writeln!(w, "\t\t\t\terr: std::ptr::null_mut()").unwrap(); + writeln!(w, "\t\t\t\terr: core::ptr::null_mut()").unwrap(); } writeln!(w, "\t\t\t}} }}").unwrap(); writeln!(w, "\t\t}}").unwrap(); @@ -220,13 +226,13 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "impl {} {{", mangled_container).unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<{}> {{", inner_type).unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return Vec::new(); }}").unwrap(); - writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap(); - writeln!(w, "\t\tself.data = std::ptr::null_mut();").unwrap(); + writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap(); + writeln!(w, "\t\tself.data = core::ptr::null_mut();").unwrap(); writeln!(w, "\t\tself.datalen = 0;").unwrap(); writeln!(w, "\t\tret").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn as_slice(&self) -> &[{}] {{", inner_type).unwrap(); - writeln!(w, "\t\tunsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap(); + writeln!(w, "\t\tunsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); @@ -244,7 +250,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "impl Drop for {} {{", mangled_container).unwrap(); writeln!(w, "\tfn drop(&mut self) {{").unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return; }}").unwrap(); - writeln!(w, "\t\tunsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap(); + writeln!(w, "\t\tlet _ = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); if clonable { @@ -252,7 +258,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); writeln!(w, "\t\tlet mut res = Vec::new();").unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return Self::from(res); }}").unwrap(); - writeln!(w, "\t\tres.extend_from_slice(unsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap(); + writeln!(w, "\t\tres.extend_from_slice(unsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap(); writeln!(w, "\t\tSelf::from(res)").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); @@ -340,27 +346,38 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, writeln!(w, "/// An enum which can either contain a {} or not", inner_type).unwrap(); writeln!(w, "pub enum {} {{", mangled_container).unwrap(); writeln!(w, "\t/// When we're in this state, this {} contains a {}", mangled_container, inner_type).unwrap(); - writeln!(w, "\tSome({}),", inner_type).unwrap(); + if inner_type != "" { + writeln!(w, "\tSome({}),", inner_type).unwrap(); + } else { + writeln!(w, "\tSome,").unwrap(); + } writeln!(w, "\t/// When we're in this state, this {} contains nothing", mangled_container).unwrap(); writeln!(w, "\tNone").unwrap(); writeln!(w, "}}").unwrap(); writeln!(w, "impl {} {{", mangled_container).unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn is_some(&self) -> bool {{").unwrap(); - writeln!(w, "\t\tif let Self::Some(_) = self {{ true }} else {{ false }}").unwrap(); + writeln!(w, "\t\tif let Self::None = self {{ false }} else {{ true }}").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn is_none(&self) -> bool {{").unwrap(); writeln!(w, "\t\t!self.is_some()").unwrap(); writeln!(w, "\t}}").unwrap(); - writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap(); - writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap(); - writeln!(w, "\t}}").unwrap(); + if inner_type != "" { + writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap(); + writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap(); + writeln!(w, "\t}}").unwrap(); + } writeln!(w, "}}").unwrap(); writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Constructs a new {} containing a {}", mangled_container, inner_type).unwrap(); - writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap(); - writeln!(w, "\t{}::Some(o)", mangled_container).unwrap(); + if inner_type != "" { + writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap(); + writeln!(w, "\t{}::Some(o)", mangled_container).unwrap(); + } else { + writeln!(w, "pub extern \"C\" fn {}_some() -> {} {{", mangled_container, mangled_container).unwrap(); + writeln!(w, "\t{}::Some", mangled_container).unwrap(); + } writeln!(w, "}}").unwrap(); writeln!(w, "#[no_mangle]").unwrap(); @@ -425,7 +442,7 @@ fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribut match token_iter.next().unwrap() { TokenTree::Literal(lit) => { // Drop the first and last chars from lit as they are always " - let doc = format!("{}", lit); + let doc = format!("{}", lit).trim().replace("\n", &format!("\n{}//!", prefix)); writeln!(w, "{}//!{}", prefix, &doc[1..doc.len() - 1]).unwrap(); }, _ => unimplemented!(), @@ -435,7 +452,7 @@ fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribut match token_iter.next().unwrap() { TokenTree::Literal(lit) => { // Drop the first and last chars from lit as they are always " - let doc = format!("{}", lit); + let doc = format!("{}", lit).trim().replace("\n", &format!("\n{}///", prefix)); writeln!(w, "{}///{}", prefix, &doc[1..doc.len() - 1]).unwrap(); }, _ => unimplemented!(), @@ -443,7 +460,7 @@ fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribut }, } } - if let Some((types, generics, inp, outp, field)) = method_args_ret { + if let Some((types, generics, inp, outp, field_ty)) = method_args_ret { let mut nullable_found = false; for (name, inp) in inp { if types.skip_arg(inp, generics) { continue; } @@ -474,8 +491,13 @@ fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribut nullable_found = true; writeln!(w, "{}/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap(); } + let field = field_ty.map(|ty| generics.resolve_type(ty)); if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = field { if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + let resolved_path = types.resolve_path(path, generics); + if types.crate_types.opaques.get(&resolved_path).is_some() { + writeln!(w, "{}/// Note that this field is expected to be a reference.", prefix).unwrap(); + } types.is_path_transparent_container(path, generics, true) } else { false } } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = field { @@ -518,22 +540,32 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t let mut first_arg = true; let mut num_unused = 0; for inp in sig.inputs.iter() { + let mut handle_self = |is_ref: bool, is_mut: bool| { + write!(w, "{}this_arg: {}{}", if !is_ref { "mut " } else { "" }, + if is_ref { + match (self_ptr, is_mut) { + (true, true) => "*mut ", + (true, false) => "*const ", + (false, true) => "&mut ", + (false, false) => "&", + } + } else { "" }, this_param).unwrap(); + assert!(first_arg); + first_arg = false; + }; match inp { syn::FnArg::Receiver(recv) => { if !recv.attrs.is_empty() { unimplemented!(); } - write!(w, "{}this_arg: {}{}", if recv.reference.is_none() { "mut " } else { "" }, - if recv.reference.is_some() { - match (self_ptr, recv.mutability.is_some()) { - (true, true) => "*mut ", - (true, false) => "*const ", - (false, true) => "&mut ", - (false, false) => "&", - } - } else { "" }, this_param).unwrap(); - assert!(first_arg); - first_arg = false; + handle_self(recv.reference.is_some(), recv.mutability.is_some()); }, syn::FnArg::Typed(arg) => { + if let syn::Pat::Ident(id) = &*arg.pat { + if format!("{}", id.ident) == "self" { + handle_self(id.by_ref.is_some(), id.mutability.is_some()); + continue; + } + } + if types.skip_arg(&*arg.ty, generics) { continue; } if !arg.attrs.is_empty() { unimplemented!(); } // First get the c type so that we can check if it ends up being a reference: @@ -554,21 +586,26 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t }, _ => unimplemented!(), } - w.write(&c_type).unwrap(); + w.write_all(&c_type).unwrap(); } } } write!(w, ")").unwrap(); match &sig.output { syn::ReturnType::Type(_, rtype) => { - write!(w, " -> ").unwrap(); - if let Some(mut remaining_path) = first_seg_self(&*rtype) { - if remaining_path.next().is_none() { - write!(w, "{}", this_param).unwrap(); - return; + let mut ret_ty = Vec::new(); + types.write_c_type(&mut ret_ty, &*rtype, generics, true); + + if !ret_ty.is_empty() { + write!(w, " -> ").unwrap(); + if let Some(mut remaining_path) = first_seg_self(&*rtype) { + if remaining_path.next().is_none() { + write!(w, "{}", this_param).unwrap(); + return; + } } + w.write_all(&ret_ty).unwrap(); } - types.write_c_type(w, &*rtype, generics, true); }, _ => {}, } @@ -584,6 +621,12 @@ pub fn write_method_var_decl_body(w: &mut W, sig: &syn::Signa match inp { syn::FnArg::Receiver(_) => {}, syn::FnArg::Typed(arg) => { + if let syn::Pat::Ident(id) = &*arg.pat { + if format!("{}", id.ident) == "self" { + continue; + } + } + if types.skip_arg(&*arg.ty, generics) { continue; } if !arg.attrs.is_empty() { unimplemented!(); } macro_rules! write_new_var { @@ -644,6 +687,17 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu } }, syn::FnArg::Typed(arg) => { + if let syn::Pat::Ident(id) = &*arg.pat { + if format!("{}", id.ident) == "self" { + if to_c { + if id.by_ref.is_none() && !matches!(&*arg.ty, syn::Type::Reference(_)) { unimplemented!(); } + write!(w, "self.this_arg").unwrap(); + first_arg = false; + } + continue; + } + } + if types.skip_arg(&*arg.ty, generics) { if !to_c { if !first_arg { @@ -725,24 +779,87 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu /// Prints concrete generic parameters for a struct/trait/function, including the less-than and /// greater-than symbols, if any generic parameters are defined. -pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_lifetimes: bool) { +pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool) { + maybe_write_generics_intern(w, generics, Some(generics_impld), types, concrete_lifetimes, false); +} + +pub fn maybe_write_non_lifetime_generics(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver) { + maybe_write_generics_intern(w, generics, Some(generics_impld), types, false, true); +} + +pub fn maybe_write_type_non_lifetime_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver) { + maybe_write_generics_intern(w, generics, None, types, false, true); +} + +fn maybe_write_generics_intern(w: &mut W, generics: &syn::Generics, generics_impld: Option<&syn::PathArguments>, types: &TypeResolver, concrete_lifetimes: bool, dummy_lifetimes: bool) { + let mut gen_types = GenericTypes::new(None); + assert!(gen_types.learn_generics(generics, types)); + if generics.params.is_empty() { return; } + for generic in generics.params.iter() { + match generic { + syn::GenericParam::Type(type_param) => { + for bound in type_param.bounds.iter() { + match bound { + syn::TypeParamBound::Trait(t) => { + if let Some(trait_bound) = types.maybe_resolve_path(&t.path, None) { + if types.skip_path(&trait_bound) { + // Just hope rust deduces generic params if some bounds are skipable. + return; + } + } + } + _ => {}, + } + } + } + _ => {}, + } + } + + write!(w, "<").unwrap(); + for (idx, generic) in generics.params.iter().enumerate() { + match generic { + syn::GenericParam::Type(type_param) => { + let mut out = Vec::new(); + let type_ident = &type_param.ident; + if types.understood_c_type(&syn::parse_quote!(#type_ident), Some(&gen_types)) { + types.write_c_type_in_generic_param(&mut out, &syn::parse_quote!(#type_ident), Some(&gen_types), false); + } else { + if let Some(syn::PathArguments::AngleBracketed(args)) = generics_impld { + if let syn::GenericArgument::Type(ty) = &args.args[idx] { + types.write_c_type_in_generic_param(&mut out, &ty, Some(&gen_types), false); + } + } + } + if !out.is_empty() { + write!(w, "{}, ", String::from_utf8(out).unwrap()).unwrap(); + } + }, + syn::GenericParam::Lifetime(lt) => { + if dummy_lifetimes { + write!(w, "'_, ").unwrap(); + } else if concrete_lifetimes { + write!(w, "'static, ").unwrap(); + } else { + write!(w, "'{}, ", lt.lifetime.ident).unwrap(); + } + }, + _ => unimplemented!(), + } + } + write!(w, ">").unwrap(); +} + +pub fn maybe_write_lifetime_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver) { let mut gen_types = GenericTypes::new(None); assert!(gen_types.learn_generics(generics, types)); - if !generics.params.is_empty() { + if generics.params.iter().any(|param| if let syn::GenericParam::Lifetime(_) = param { true } else { false }) { write!(w, "<").unwrap(); for (idx, generic) in generics.params.iter().enumerate() { match generic { - syn::GenericParam::Type(type_param) => { - write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap(); - let type_ident = &type_param.ident; - types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false); - }, + syn::GenericParam::Type(_) => {}, syn::GenericParam::Lifetime(lt) => { - if concrete_lifetimes { - write!(w, "'static").unwrap(); - } else { - write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); - } + write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); }, _ => unimplemented!(), } @@ -750,5 +867,3 @@ pub fn maybe_write_generics(w: &mut W, generics: &syn::Generi write!(w, ">").unwrap(); } } - -