Skip to content

Commit 47eca1f

Browse files
TheBlueMattTheBlueMatt
committed
Swap pointers for references where we can
1 parent b370eda commit 47eca1f

File tree

13 files changed

+257
-244
lines changed

13 files changed

+257
-244
lines changed

‎c-bindings-gen/src/main.rs

Lines changed: 23 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ fn println_docs<W: std::io::Write>(w: &mut W, attrs: &[syn::Attribute], prefix:
4848
}
4949
}
5050

51-
fn print_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, associated_types: &HashMap<&syn::Ident, &syn::Ident>, this_param: &str, types: &TypeResolver, generics: Option<&GenericTypes>) {
51+
fn print_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, associated_types: &HashMap<&syn::Ident, &syn::Ident>, this_param: &str, types: &TypeResolver, generics: Option<&GenericTypes>, self_ptr: bool) {
5252
if sig.constness.is_some() || sig.asyncness.is_some() || sig.unsafety.is_some() ||
5353
sig.abi.is_some() || sig.variadic.is_some() || sig.generics.where_clause.is_some() {
5454
unimplemented!();
@@ -71,7 +71,9 @@ fn print_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, assoc
7171
syn::FnArg::Receiver(recv) => {
7272
if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); }
7373
if recv.reference.as_ref().unwrap().1.is_some() { unimplemented!(); }
74-
write!(w, "this_arg: *{} {}", if recv.mutability.is_some() { "mut" } else { "const" }, this_param).unwrap();
74+
write!(w, "this_arg: {}{} {}",
75+
if self_ptr && recv.mutability.is_some() { "*" } else if self_ptr { "*const " } else { "&" },
76+
if recv.mutability.is_some() { "mut " } else { "" }, this_param).unwrap();
7577
assert!(first_arg);
7678
first_arg = false;
7779
},
@@ -89,7 +91,7 @@ fn print_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, assoc
8991
}
9092
_ => unimplemented!(),
9193
}
92-
types.print_c_type(w, &*arg.ty, generics);
94+
types.print_c_type(w, &*arg.ty, generics, false);
9395
}
9496
}
9597
}
@@ -105,12 +107,12 @@ fn print_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, assoc
105107
ident: (*real_type).clone(),
106108
arguments: syn::PathArguments::None
107109
}.into()
108-
}), generics);
110+
}), generics, true);
109111
} else {
110112
write!(w, "{}", this_param).unwrap();
111113
}
112114
} else {
113-
types.print_c_type(w, &*rtype, generics);
115+
types.print_c_type(w, &*rtype, generics, true);
114116
}
115117
},
116118
_ => {},
@@ -153,7 +155,7 @@ fn print_method_var_decl_body<W: std::io::Write>(w: &mut W, sig: &syn::Signature
153155
if first_seg_self(&*rtype).is_some() {
154156
write!(w, "let ret = ").unwrap();
155157
} else {
156-
types.print_to_c_conversion_inline_prefix(w, &*rtype, generics);
158+
types.print_to_c_conversion_inline_prefix(w, &*rtype, generics, true);
157159
}
158160
}
159161
},
@@ -187,9 +189,9 @@ fn print_method_call_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature,
187189
}
188190
first_arg = false;
189191
if to_c {
190-
types.print_to_c_conversion_inline_prefix(w, &*arg.ty, generics);
192+
types.print_to_c_conversion_inline_prefix(w, &*arg.ty, generics, false);
191193
write!(w, "{}", ident.ident).unwrap();
192-
types.print_to_c_conversion_inline_suffix(w, &*arg.ty, generics);
194+
types.print_to_c_conversion_inline_suffix(w, &*arg.ty, generics, false);
193195
} else {
194196
types.print_from_c_conversion_prefix(w, &*arg.ty, generics);
195197
write!(w, "{}", ident.ident).unwrap();
@@ -210,7 +212,7 @@ fn print_method_call_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature,
210212
if first_seg_self(&*rtype).is_some() {
211213
write!(w, ";\n\t{} {{ inner: Box::into_raw(Box::new(ret)) }}", this_type).unwrap();
212214
} else {
213-
types.print_to_c_conversion_inline_suffix(w, &*rtype, generics);
215+
types.print_to_c_conversion_inline_suffix(w, &*rtype, generics, true);
214216
}
215217
}
216218
}
@@ -303,7 +305,7 @@ fn println_trait<'a, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, module
303305
if m.default.is_some() { unimplemented!(); }
304306
println_docs(w, &m.attrs, "\t");
305307
write!(w, "\tpub {}: extern \"C\" fn (", m.sig.ident).unwrap();
306-
print_method_params(w, &m.sig, &associated_types, "c_void", types, None);
308+
print_method_params(w, &m.sig, &associated_types, "c_void", types, None, true);
307309
write!(w, ",\n").unwrap();
308310
},
309311
&syn::TraitItem::Type(ref t) => {
@@ -498,24 +500,24 @@ fn println_struct<W: std::io::Write>(w: &mut W, s: &syn::ItemStruct, module_path
498500
and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None,
499501
elem: Box::new(field.ty.clone()) });
500502
if types.understood_c_type(&ref_type, Some(&gen_types)) {
501-
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: *const {}) -> ", struct_name, ident, struct_name).unwrap();
502-
types.print_c_type(w, &ref_type, Some(&gen_types));
503+
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_get_{}(this_ptr: &{}) -> ", struct_name, ident, struct_name).unwrap();
504+
types.print_c_type(w, &ref_type, Some(&gen_types), true);
503505
write!(w, " {{\n\t").unwrap();
504506
types.print_to_c_conversion_new_var(w, &ident, &ref_type, Some(&gen_types));
505-
types.print_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types));
506-
write!(w, "&unsafe {{ &*(*this_ptr).inner }}.{}", ident).unwrap();
507-
types.print_to_c_conversion_inline_suffix(w, &ref_type, Some(&gen_types));
507+
types.print_to_c_conversion_inline_prefix(w, &ref_type, Some(&gen_types), true);
508+
write!(w, "&unsafe {{ &*this_ptr.inner }}.{}", ident).unwrap();
509+
types.print_to_c_conversion_inline_suffix(w, &ref_type, Some(&gen_types), true);
508510
write!(w, "\n}}\n").unwrap();
509511
}
510512

511513
if types.understood_c_type(&field.ty, Some(&gen_types)) {
512-
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: *mut {}, val: ", struct_name, ident, struct_name).unwrap();
513-
types.print_c_type(w, &field.ty, Some(&gen_types));
514+
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_set_{}(this_ptr: &mut {}, val: ", struct_name, ident, struct_name).unwrap();
515+
types.print_c_type(w, &field.ty, Some(&gen_types), false);
514516
write!(w, ") {{\n\t").unwrap();
515517
if types.print_from_c_conversion_new_var(w, &ident, &field.ty, Some(&gen_types)) {
516518
write!(w, "\n\t").unwrap();
517519
}
518-
write!(w, "unsafe {{ &mut *((*this_ptr).inner as *mut ln{}) }}.{} = ", s.ident, ident).unwrap();
520+
write!(w, "unsafe {{ &mut *(this_ptr.inner as *mut ln{}) }}.{} = ", s.ident, ident).unwrap();
519521
types.print_from_c_conversion_prefix(w, &field.ty, Some(&gen_types));
520522
write!(w, "val").unwrap();
521523
types.print_from_c_conversion_suffix(w, &field.ty, Some(&gen_types));
@@ -531,7 +533,7 @@ fn println_struct<W: std::io::Write>(w: &mut W, s: &syn::ItemStruct, module_path
531533
for (idx, field) in fields.named.iter().enumerate() {
532534
if idx != 0 { write!(w, ", ").unwrap(); }
533535
write!(w, "{}_arg: ", field.ident.as_ref().unwrap()).unwrap();
534-
types.print_c_type(w, &field.ty, Some(&gen_types));
536+
types.print_c_type(w, &field.ty, Some(&gen_types), false);
535537
}
536538
write!(w, ") -> {} {{\n\t", struct_name).unwrap();
537539
for field in fields.named.iter() {
@@ -591,7 +593,7 @@ eprintln!("WIP: IMPL {:?} FOR {}", trait_path.1, ident);
591593
DeclType::StructImported(newname) => format!("{}", newname),
592594
_ => unimplemented!(),
593595
};
594-
print_method_params(w, &m.sig, &HashMap::new(), &ret_type, types, Some(&gen_types));
596+
print_method_params(w, &m.sig, &HashMap::new(), &ret_type, types, Some(&gen_types), false);
595597
write!(w, " {{\n\t").unwrap();
596598
print_method_var_decl_body(w, &m.sig, "", types, Some(&gen_types), false);
597599
let mut takes_self = false;
@@ -601,7 +603,7 @@ eprintln!("WIP: IMPL {:?} FOR {}", trait_path.1, ident);
601603
}
602604
}
603605
if takes_self {
604-
write!(w, "unsafe {{ &*(*this_arg).inner }}.{}(", m.sig.ident).unwrap();
606+
write!(w, "unsafe {{ &*this_arg.inner }}.{}(", m.sig.ident).unwrap();
605607
} else {
606608
write!(w, "lightning::{}::{}(", resolved_path, m.sig.ident).unwrap();
607609
}

‎c-bindings-gen/src/types.rs

Lines changed: 40 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -354,6 +354,7 @@ impl<'a> TypeResolver<'a> {
354354
return Some("");
355355
}
356356
match full_path {
357+
"bitcoin::secp256k1::key::PublicKey" if is_ref => Some("crate::c_types::PublicKey::from_rust("),
357358
"bitcoin::secp256k1::key::PublicKey" => Some("crate::c_types::PublicKey::from_rust(&"),
358359
"bitcoin::blockdata::script::Script" => Some("crate::c_types::Script::from_slice(&c_"),
359360
"bitcoin::blockdata::transaction::Transaction" => Some("crate::c_types::Transaction::from_slice(&c_"),
@@ -637,11 +638,11 @@ impl<'a> TypeResolver<'a> {
637638
}
638639
}
639640

640-
fn print_to_c_conversion_inline_prefix_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool) {
641+
fn print_to_c_conversion_inline_prefix_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, ptr_for_ref: bool) {
641642
match t {
642643
syn::Type::Reference(r) => {
643644
if r.lifetime.is_some() { unimplemented!(); }
644-
self.print_to_c_conversion_inline_prefix_intern(w, &*r.elem, generics, true);
645+
self.print_to_c_conversion_inline_prefix_intern(w, &*r.elem, generics, true, ptr_for_ref);
645646
},
646647
syn::Type::Path(p) => {
647648
if p.qself.is_some() || p.path.leading_colon.is_some() {
@@ -667,8 +668,12 @@ impl<'a> TypeResolver<'a> {
667668
} else if let Some(decl_type) = self.declared.get(ident) {
668669
match decl_type {
669670
DeclType::MirroredEnum => write!(w, "{}::from_ln(", ident).unwrap(),
670-
DeclType::StructImported(name) if is_ref => write!(w, "Box::into_raw(Box::new({} {{ inner: ", name).unwrap(),
671-
DeclType::StructImported(name) if !is_ref => write!(w, "{} {{ inner: Box::into_raw(Box::new(", name).unwrap(),
671+
DeclType::StructImported(name) if is_ref && ptr_for_ref =>
672+
write!(w, "Box::into_raw(Box::new({} {{ inner: ", name).unwrap(),
673+
DeclType::StructImported(name) if is_ref =>
674+
write!(w, "&{} {{ inner: ", name).unwrap(),
675+
DeclType::StructImported(name) if !is_ref =>
676+
write!(w, "{} {{ inner: Box::into_raw(Box::new(", name).unwrap(),
672677
_ => {},
673678
}
674679
} else { unimplemented!(); }
@@ -697,14 +702,14 @@ impl<'a> TypeResolver<'a> {
697702
_ => unimplemented!(),
698703
}
699704
}
700-
pub fn print_to_c_conversion_inline_prefix<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>) {
701-
self.print_to_c_conversion_inline_prefix_intern(w, t, generics, false);
705+
pub fn print_to_c_conversion_inline_prefix<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) {
706+
self.print_to_c_conversion_inline_prefix_intern(w, t, generics, false, ptr_for_ref);
702707
}
703-
pub fn print_to_c_conversion_inline_suffix_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool) {
708+
pub fn print_to_c_conversion_inline_suffix_intern<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, ptr_for_ref: bool) {
704709
match t {
705710
syn::Type::Reference(r) => {
706711
if r.lifetime.is_some() { unimplemented!(); }
707-
self.print_to_c_conversion_inline_suffix_intern(w, &*r.elem, generics, true);
712+
self.print_to_c_conversion_inline_suffix_intern(w, &*r.elem, generics, true, ptr_for_ref);
708713
},
709714
syn::Type::Path(p) => {
710715
if p.qself.is_some() || p.path.leading_colon.is_some() {
@@ -730,7 +735,8 @@ impl<'a> TypeResolver<'a> {
730735
} else if let Some(decltype) = self.declared.get(ident) {
731736
match decltype {
732737
DeclType::MirroredEnum => write!(w, ")").unwrap(),
733-
DeclType::StructImported(_) if is_ref => write!(w, " }}))").unwrap(),
738+
DeclType::StructImported(_) if is_ref && ptr_for_ref => write!(w, " }} ))").unwrap(),
739+
DeclType::StructImported(_) if is_ref => write!(w, " }}").unwrap(),
734740
DeclType::StructImported(_) if !is_ref => write!(w, ")) }}").unwrap(),
735741
_ => {},
736742
}
@@ -752,8 +758,8 @@ impl<'a> TypeResolver<'a> {
752758
_ => unimplemented!(),
753759
}
754760
}
755-
pub fn print_to_c_conversion_inline_suffix<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>) {
756-
self.print_to_c_conversion_inline_suffix_intern(w, t, generics, false);
761+
pub fn print_to_c_conversion_inline_suffix<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) {
762+
self.print_to_c_conversion_inline_suffix_intern(w, t, generics, false, ptr_for_ref);
757763
}
758764
pub fn print_to_c_conversion_new_var<W: std::io::Write>(&self, w: &mut W, ident: &syn::Ident, t: &syn::Type, generics: Option<&GenericTypes>) -> bool {
759765
match t {
@@ -882,7 +888,6 @@ impl<'a> TypeResolver<'a> {
882888
DeclType::StructImported(_) => {},
883889
DeclType::EnumIgnored => unimplemented!(),
884890
DeclType::MirroredEnum => {},
885-
DeclType::Trait(_) if is_ref => write!(w, "unsafe {{ &*").unwrap(),
886891
DeclType::Trait(_) => {},
887892
}
888893
return;
@@ -946,7 +951,6 @@ impl<'a> TypeResolver<'a> {
946951
DeclType::StructImported(_) => {},
947952
DeclType::EnumIgnored => unimplemented!(),
948953
DeclType::MirroredEnum => {},
949-
DeclType::Trait(_) if is_ref => write!(w, " }}").unwrap(),
950954
DeclType::Trait(_) => {},
951955
}
952956
return;
@@ -989,7 +993,7 @@ impl<'a> TypeResolver<'a> {
989993
self.print_from_c_conversion_suffix_intern(w, t, generics, false);
990994
}
991995

992-
fn print_c_ident_intern<W: std::io::Write>(&self, w: &mut W, ident: &syn::Ident, is_ref: bool, is_mut: bool) -> bool {
996+
fn print_c_ident_intern<W: std::io::Write>(&self, w: &mut W, ident: &syn::Ident, is_ref: bool, is_mut: bool, ptr_for_ref: bool) -> bool {
993997
let full_path = match self.maybe_resolve_path(&syn::Path::from(ident.clone())) {
994998
Some(path) => path, None => return false };
995999
if let Some(c_type) = self.c_type_from_path(&full_path, is_ref) {
@@ -1001,24 +1005,31 @@ impl<'a> TypeResolver<'a> {
10011005
}
10021006
if let DeclType::StructImported(name) = decl_type {
10031007
if is_mut { unimplemented!(); }
1004-
if is_ref {
1008+
if is_ref && ptr_for_ref {
10051009
write!(w, "*const {}", name).unwrap();
1010+
} else if is_ref {
1011+
write!(w, "&{}", name).unwrap();
10061012
} else {
10071013
write!(w, "{}", name).unwrap();
10081014
}
10091015
} else {
1016+
if is_ref && ptr_for_ref {
1017+
write!(w, "*{}", if !is_mut {"const"} else {""}).unwrap();
1018+
} else if is_ref {
1019+
write!(w, "&").unwrap();
1020+
}
10101021
if is_ref && is_mut {
1011-
write!(w, "*mut {}", ident).unwrap();
1022+
write!(w, "mut {}", ident).unwrap();
10121023
} else if is_ref {
1013-
write!(w, "*const {}", ident).unwrap();
1024+
write!(w, " {}", ident).unwrap();
10141025
} else {
10151026
write!(w, "{}", ident).unwrap();
10161027
}
10171028
}
10181029
true
10191030
} else { false }
10201031
}
1021-
fn print_c_type_intern<W: std::io::Write>(&self, generics: Option<&GenericTypes>, w: &mut W, t: &syn::Type, is_ref: bool, is_mut: bool) -> bool {
1032+
fn print_c_type_intern<W: std::io::Write>(&self, generics: Option<&GenericTypes>, w: &mut W, t: &syn::Type, is_ref: bool, is_mut: bool, ptr_for_ref: bool) -> bool {
10221033
match t {
10231034
syn::Type::Path(p) => {
10241035
if p.qself.is_some() || p.path.leading_colon.is_some() {
@@ -1027,39 +1038,39 @@ impl<'a> TypeResolver<'a> {
10271038
if let Some(gen_types) = generics {
10281039
if let Some(resolved) = gen_types.maybe_resolve_path(&p.path) {
10291040
if self.is_known_container(&resolved.0) { return false; }
1030-
return self.print_c_ident_intern(w, &resolved.1, is_ref, is_mut);
1041+
return self.print_c_ident_intern(w, &resolved.1, is_ref, is_mut, ptr_for_ref);
10311042
}
10321043
}
10331044
if let Some(full_path) = self.maybe_resolve_path(&p.path) {
10341045
if self.is_known_container(&full_path) {
10351046
if let syn::PathArguments::AngleBracketed(args) = &p.path.segments.iter().next().unwrap().arguments {
10361047
if args.args.len() != 1 { return false; }
10371048
if let syn::GenericArgument::Type(t) = args.args.iter().next().unwrap() {
1038-
return self.print_c_type_intern(generics, w, t, false, false);
1049+
return self.print_c_type_intern(generics, w, t, false, false, ptr_for_ref);
10391050
} else { return false; }
10401051
} else { return false; }
10411052
}
10421053
}
10431054
if p.path.leading_colon.is_some() { return false; }
10441055
if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
1045-
self.print_c_ident_intern(w, &ident, is_ref, is_mut)
1056+
self.print_c_ident_intern(w, &ident, is_ref, is_mut, ptr_for_ref)
10461057
} else { false }
10471058
},
10481059
syn::Type::Reference(r) => {
10491060
if r.lifetime.is_some() { return false; }
1050-
self.print_c_type_intern(generics, w, &*r.elem, true, r.mutability.is_some())
1061+
self.print_c_type_intern(generics, w, &*r.elem, true, r.mutability.is_some(), ptr_for_ref)
10511062
},
10521063
syn::Type::Array(a) => {
10531064
if is_ref && is_mut {
10541065
write!(w, "*mut [").unwrap();
1055-
if !self.print_c_type_intern(generics, w, &a.elem, false, false) { return false; }
1066+
if !self.print_c_type_intern(generics, w, &a.elem, false, false, ptr_for_ref) { return false; }
10561067
} else if is_ref {
10571068
write!(w, "*const [").unwrap();
1058-
if !self.print_c_type_intern(generics, w, &a.elem, false, false) { return false; }
1069+
if !self.print_c_type_intern(generics, w, &a.elem, false, false, ptr_for_ref) { return false; }
10591070
} else {
10601071
write!(w, "crate::c_types::ThirtyTwoBytes").unwrap();
10611072
let mut typecheck = Vec::new();
1062-
if !self.print_c_type_intern(generics, &mut typecheck, &a.elem, false, false) { return false; }
1073+
if !self.print_c_type_intern(generics, &mut typecheck, &a.elem, false, false, ptr_for_ref) { return false; }
10631074
if typecheck[..] != ['u' as u8, '8' as u8] { return false; }
10641075
}
10651076
if let syn::Expr::Lit(l) = &a.len {
@@ -1087,16 +1098,16 @@ impl<'a> TypeResolver<'a> {
10871098
_ => false,
10881099
}
10891100
}
1090-
pub fn print_c_type<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>) {
1091-
assert!(self.print_c_type_intern(generics, w, t, false, false));
1101+
pub fn print_c_type<W: std::io::Write>(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) {
1102+
assert!(self.print_c_type_intern(generics, w, t, false, false, ptr_for_ref));
10921103
}
10931104
pub fn understood_c_path(&self, p: &syn::Path) -> bool {
10941105
if p.leading_colon.is_some() { return false; }
10951106
if let Some(ident) = single_ident_generic_path_to_ident(p) {
1096-
self.print_c_ident_intern(&mut std::io::sink(), ident, false, false)
1107+
self.print_c_ident_intern(&mut std::io::sink(), ident, false, false, false)
10971108
} else { false }
10981109
}
10991110
pub fn understood_c_type(&self, t: &syn::Type, generics: Option<&GenericTypes>) -> bool {
1100-
self.print_c_type_intern(generics, &mut std::io::sink(), t, false, false)
1111+
self.print_c_type_intern(generics, &mut std::io::sink(), t, false, false, false)
11011112
}
11021113
}

‎genbindings.sh

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
#!/bin/bash
22

3+
rm lightning-c-bindings/src/{ln,util,chain,routing}/*
34
set -e
45
cd c-bindings-gen && cargo build && cd ..
56
GEN="$(pwd)/c-bindings-gen/target/debug/c-bindings-gen"
@@ -8,7 +9,6 @@ OUT="$(pwd)/lightning-c-bindings/src"
89
OUT_F="$(pwd)/lightning-c-bindings/include/rust_types.h"
910
echo > $OUT_F
1011

11-
rm lightning-c-bindings/src/{ln,util,chain,routing}/*
1212
RUST_BACKTRACE=1 $GEN $SRC/ $OUT/ lightning "" $OUT_F
1313

1414
cd lightning-c-bindings

‎lightning-c-bindings/src/chain/chaininterface.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ impl ChainError {
5050
pub struct BroadcasterInterface {
5151
pub this_arg: *mut c_void,
5252
/// " Sends a transaction out to (hopefully) be mined."
53-
pub broadcast_transaction: extern "C" fn (this_arg: *const c_void, tx: crate::c_types::Transaction),
53+
pub broadcast_transaction: extern "C" fn (this_arg: *const c_void, tx: crate::c_types::Transaction),
5454
}
5555
unsafe impl Sync for BroadcasterInterface {}
5656
unsafe impl Send for BroadcasterInterface {}
@@ -118,7 +118,7 @@ pub struct FeeEstimator {
118118
/// " This translates to:"
119119
/// " * satoshis-per-byte * 250"
120120
/// " * ceil(satoshis-per-kbyte / 4)"
121-
pub get_est_sat_per_1000_weight: extern "C" fn (this_arg: *const c_void, confirmation_target: ConfirmationTarget) -> u64,
121+
pub get_est_sat_per_1000_weight: extern "C" fn (this_arg: *const c_void, confirmation_target: ConfirmationTarget) -> u64,
122122
}
123123
unsafe impl Sync for FeeEstimator {}
124124
unsafe impl Send for FeeEstimator {}

0 commit comments

Comments
 (0)