Line data Source code
1 : use lief_ffi as ffi;
2 : use cxx::memory::UniquePtrTarget;
3 : use std::marker::PhantomData;
4 :
5 : use crate::Range;
6 :
7 : #[doc(hidden)]
8 : pub trait FromFFI<T: UniquePtrTarget> {
9 : fn from_ffi(ptr: cxx::UniquePtr<T>) -> Self;
10 : }
11 :
12 : #[doc(hidden)]
13 2024550 : pub fn into_optional<T: FromFFI<U>, U: UniquePtrTarget>(raw_ffi: cxx::UniquePtr<U>) -> Option<T> {
14 2024550 : if raw_ffi.is_null() {
15 1132430 : None
16 : } else {
17 892120 : Some(T::from_ffi(raw_ffi))
18 : }
19 2024550 : }
20 :
21 :
22 : #[doc(hidden)]
23 0 : pub fn into_ranges(raw_ffi: cxx::UniquePtr<cxx::CxxVector<ffi::Range>>) -> Vec<Range> {
24 0 : let cxx_vec = raw_ffi.as_ref().unwrap();
25 0 : if cxx_vec.is_empty() {
26 0 : return Vec::new();
27 0 : }
28 0 :
29 0 : let mut rust_range: Vec<Range> = Vec::with_capacity(cxx_vec.len());
30 :
31 0 : for ffi_range in cxx_vec {
32 0 : rust_range.push(Range::from_ffi(ffi_range));
33 0 : }
34 :
35 0 : rust_range
36 0 : }
37 :
38 : pub struct Iterator<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> {
39 : #[doc(hidden)]
40 : pub it: cxx::UniquePtr<It>,
41 : _owner: PhantomData<&'a Parent>,
42 : }
43 :
44 : impl<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> Iterator<'a, Parent, It> {
45 : #[doc(hidden)]
46 27530 : pub fn new(it: cxx::UniquePtr<It>) -> Self {
47 27530 : Self {
48 27530 : it,
49 27530 : _owner: PhantomData,
50 27530 : }
51 27530 : }
52 : }
53 :
54 : #[doc(hidden)]
55 : #[macro_export]
56 : macro_rules! declare_iterator_conv {
57 : ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty, $conv: expr) => {
58 : pub type $name<'a> = $crate::common::Iterator<'a, $parent, $ffi_iterator>;
59 : impl<'a> Iterator for $name<'a> {
60 : type Item = $from;
61 2283780 : fn next(&mut self) -> Option<Self::Item> {
62 2283780 : let next = self.it.as_mut().unwrap().next();
63 2283780 : if next.is_null() {
64 27530 : None
65 : } else {
66 2256250 : Some($conv(next))
67 : }
68 2283780 : }
69 : }
70 : impl<'a> ExactSizeIterator for $name<'a> {
71 0 : fn len(&self) -> usize {
72 0 : self.it.as_ref().unwrap().size().try_into().unwrap()
73 0 : }
74 : }
75 : };
76 : }
77 :
78 : #[doc(hidden)]
79 : #[macro_export]
80 : macro_rules! declare_iterator {
81 : ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty) => {
82 : $crate::declare_iterator_conv!($name, $from, $ffi, $parent, $ffi_iterator, |n| {
83 : Self::Item::from_ffi(n)
84 : });
85 : };
86 : }
87 :
88 : pub struct ForwardIterator<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> {
89 : #[doc(hidden)]
90 : pub it: cxx::UniquePtr<It>,
91 : _owner: PhantomData<&'a Parent>,
92 : }
93 :
94 : impl<'a, Parent: UniquePtrTarget, It: UniquePtrTarget> ForwardIterator<'a, Parent, It> {
95 : #[doc(hidden)]
96 140 : pub fn new(it: cxx::UniquePtr<It>) -> Self {
97 140 : Self {
98 140 : it,
99 140 : _owner: PhantomData,
100 140 : }
101 140 : }
102 : }
103 :
104 : #[doc(hidden)]
105 : #[macro_export]
106 : macro_rules! declare_fwd_iterator_conv {
107 : ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty, $conv: expr) => {
108 : pub type $name<'a> = $crate::common::ForwardIterator<'a, $parent, $ffi_iterator>;
109 : impl<'a> Iterator for $name<'a> {
110 : type Item = $from;
111 65830 : fn next(&mut self) -> Option<Self::Item> {
112 65830 : let next = self.it.as_mut().unwrap().next();
113 65830 : if next.is_null() {
114 140 : None
115 : } else {
116 65690 : Some($conv(next))
117 : }
118 65830 : }
119 : }
120 : };
121 : }
122 :
123 : #[doc(hidden)]
124 : #[macro_export]
125 : macro_rules! declare_fwd_iterator {
126 : ($name:ident, $from:ty, $ffi:ty, $parent:ty, $ffi_iterator:ty) => {
127 : $crate::declare_fwd_iterator_conv!($name, $from, $ffi, $parent, $ffi_iterator, |n| {
128 : Self::Item::from_ffi(n)
129 : });
130 : };
131 : }
132 :
133 :
134 : #[doc(hidden)]
135 : #[macro_export]
136 : macro_rules! to_slice {
137 : ($e:expr) => {
138 : let content_ptr = $e;
139 : unsafe {
140 : if content_ptr.size > 0 {
141 : return std::slice::from_raw_parts_mut(content_ptr.ptr, content_ptr.size as usize);
142 : }
143 : return &[];
144 : }
145 : };
146 : }
147 :
148 :
149 : #[doc(hidden)]
150 : #[macro_export]
151 : macro_rules! to_result {
152 : ($func: expr, $self: expr, $($arg:tt)*) => {
153 : let mut err: u32 = 0;
154 :
155 : let value = $func(&$self.ptr, $($arg),*, std::pin::Pin::new(&mut err));
156 : if err > 0 {
157 : return Err($crate::Error::from(err));
158 : }
159 : return Ok(value);
160 : };
161 : ($func: expr, $self: expr) => {
162 : let mut err: u32 = 0;
163 : let value = $func(&$self.ptr, std::pin::Pin::new(&mut err));
164 :
165 : if err > 0 {
166 : return Err($crate::Error::from(err));
167 : }
168 : return Ok(value);
169 : };
170 : }
171 :
172 : #[doc(hidden)]
173 : #[macro_export]
174 : macro_rules! to_conv_result {
175 : ($func: expr, $self: expr, $conv: expr, $($arg:tt)*) => {
176 : let mut err: u32 = 0;
177 : let value = $func(&$self, $($arg),*, std::pin::Pin::new(&mut err));
178 : if err > 0 {
179 : return Err($crate::Error::from(err));
180 : }
181 : return Ok($conv(value));
182 : };
183 : ($func: expr, $self: expr, $conv: expr) => {
184 : let mut err: u32 = 0;
185 : let value = $func(&$self, std::pin::Pin::new(&mut err));
186 : if err > 0 {
187 : return Err($crate::Error::from(err));
188 : }
189 : return Ok($conv(value));
190 : };
191 : }
|
