Line data Source code
1 : use lief_ffi as ffi;
2 :
3 : use crate::{common::FromFFI};
4 :
5 : use std::marker::PhantomData;
6 : use crate::declare_fwd_iterator;
7 :
8 : pub mod simple;
9 : pub mod array;
10 : pub mod bitfield;
11 : pub mod classlike;
12 : pub mod enum_ty;
13 : pub mod function;
14 : pub mod modifier;
15 : pub mod pointer;
16 : pub mod union;
17 : pub mod attribute;
18 : pub mod method;
19 :
20 : #[doc(inline)]
21 : pub use simple::Simple;
22 :
23 : #[doc(inline)]
24 : pub use array::Array;
25 :
26 : #[doc(inline)]
27 : pub use bitfield::BitField;
28 :
29 : #[doc(inline)]
30 : pub use classlike::{Class, Structure, Interface};
31 :
32 : #[doc(inline)]
33 : pub use enum_ty::Enum;
34 :
35 : #[doc(inline)]
36 : pub use function::Function;
37 :
38 : #[doc(inline)]
39 : pub use modifier::Modifier;
40 :
41 : #[doc(inline)]
42 : pub use pointer::Pointer;
43 :
44 : #[doc(inline)]
45 : pub use union::Union;
46 :
47 : #[doc(inline)]
48 : pub use attribute::Attribute;
49 :
50 : #[doc(inline)]
51 : pub use method::Method;
52 :
53 : pub enum Type<'a> {
54 : /// Represent primitive types (int, float, ...)
55 : Simple(Simple<'a>),
56 :
57 : /// Mirror `LF_ARRAY`
58 : Array(Array<'a>),
59 :
60 : /// Mirror `LF_BITFIELD
61 : BitField(BitField<'a>),
62 :
63 : /// Mirror `LF_CLASS
64 : Class(Class<'a>),
65 :
66 : /// Mirror `LF_STRUCTURE
67 : Structure(Structure<'a>),
68 :
69 : /// Mirror `LF_INTERFACE
70 : Interface(Interface<'a>),
71 :
72 : /// Mirror `LF_ENUM
73 : Enum(Enum<'a>),
74 :
75 : /// Mirror `LF_PROCEDURE
76 : Function(Function<'a>),
77 :
78 : /// Mirror `LF_MODIFIER
79 : Modifier(Modifier<'a>),
80 :
81 : /// Mirror `LF_POINTER
82 : Pointer(Pointer<'a>),
83 :
84 : /// Mirror `LF_UNION
85 : Union(Union<'a>),
86 :
87 : Generic(Generic<'a>),
88 : }
89 :
90 : impl FromFFI<ffi::PDB_Type> for Type<'_> {
91 0 : fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::PDB_Type>) -> Self {
92 0 : unsafe {
93 0 : let type_ref = ffi_entry.as_ref().unwrap();
94 0 :
95 0 : if ffi::PDB_types_Simple::classof(type_ref) {
96 0 : let raw = {
97 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
98 0 : type To = cxx::UniquePtr<ffi::PDB_types_Simple>;
99 0 : std::mem::transmute::<From, To>(ffi_entry)
100 0 : };
101 0 : Type::Simple(Simple::from_ffi(raw))
102 0 : } else if ffi::PDB_types_Array::classof(type_ref) {
103 0 : let raw = {
104 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
105 0 : type To = cxx::UniquePtr<ffi::PDB_types_Array>;
106 0 : std::mem::transmute::<From, To>(ffi_entry)
107 0 : };
108 0 : Type::Array(Array::from_ffi(raw))
109 0 : } else if ffi::PDB_types_BitField::classof(type_ref) {
110 0 : let raw = {
111 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
112 0 : type To = cxx::UniquePtr<ffi::PDB_types_BitField>;
113 0 : std::mem::transmute::<From, To>(ffi_entry)
114 0 : };
115 0 : Type::BitField(BitField::from_ffi(raw))
116 0 : } else if ffi::PDB_types_Class::classof(type_ref) {
117 0 : let raw = {
118 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
119 0 : type To = cxx::UniquePtr<ffi::PDB_types_Class>;
120 0 : std::mem::transmute::<From, To>(ffi_entry)
121 0 : };
122 0 : Type::Class(Class::from_ffi(raw))
123 0 : } else if ffi::PDB_types_Structure::classof(type_ref) {
124 0 : let raw = {
125 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
126 0 : type To = cxx::UniquePtr<ffi::PDB_types_Structure>;
127 0 : std::mem::transmute::<From, To>(ffi_entry)
128 0 : };
129 0 : Type::Structure(Structure::from_ffi(raw))
130 0 : } else if ffi::PDB_types_Interface::classof(type_ref) {
131 0 : let raw = {
132 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
133 0 : type To = cxx::UniquePtr<ffi::PDB_types_Interface>;
134 0 : std::mem::transmute::<From, To>(ffi_entry)
135 0 : };
136 0 : Type::Interface(Interface::from_ffi(raw))
137 0 : } else if ffi::PDB_types_Enum::classof(type_ref) {
138 0 : let raw = {
139 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
140 0 : type To = cxx::UniquePtr<ffi::PDB_types_Enum>;
141 0 : std::mem::transmute::<From, To>(ffi_entry)
142 0 : };
143 0 : Type::Enum(Enum::from_ffi(raw))
144 0 : } else if ffi::PDB_types_Function::classof(type_ref) {
145 0 : let raw = {
146 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
147 0 : type To = cxx::UniquePtr<ffi::PDB_types_Function>;
148 0 : std::mem::transmute::<From, To>(ffi_entry)
149 0 : };
150 0 : Type::Function(Function::from_ffi(raw))
151 0 : } else if ffi::PDB_types_Modifier::classof(type_ref) {
152 0 : let raw = {
153 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
154 0 : type To = cxx::UniquePtr<ffi::PDB_types_Modifier>;
155 0 : std::mem::transmute::<From, To>(ffi_entry)
156 0 : };
157 0 : Type::Modifier(Modifier::from_ffi(raw))
158 0 : } else if ffi::PDB_types_Pointer::classof(type_ref) {
159 0 : let raw = {
160 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
161 0 : type To = cxx::UniquePtr<ffi::PDB_types_Pointer>;
162 0 : std::mem::transmute::<From, To>(ffi_entry)
163 0 : };
164 0 : Type::Pointer(Pointer::from_ffi(raw))
165 0 : } else if ffi::PDB_types_Union::classof(type_ref) {
166 0 : let raw = {
167 0 : type From = cxx::UniquePtr<ffi::PDB_Type>;
168 0 : type To = cxx::UniquePtr<ffi::PDB_types_Union>;
169 0 : std::mem::transmute::<From, To>(ffi_entry)
170 0 : };
171 0 : Type::Union(Union::from_ffi(raw))
172 : } else {
173 0 : Type::Generic(Generic::from_ffi(ffi_entry))
174 : }
175 : }
176 0 : }
177 : }
178 :
179 : pub struct Generic<'a> {
180 : ptr: cxx::UniquePtr<ffi::PDB_Type>,
181 : _owner: PhantomData<&'a ()>,
182 : }
183 :
184 : impl FromFFI<ffi::PDB_Type> for Generic<'_> {
185 0 : fn from_ffi(cmd: cxx::UniquePtr<ffi::PDB_Type>) -> Self {
186 0 : Self {
187 0 : ptr: cmd,
188 0 : _owner: PhantomData,
189 0 : }
190 0 : }
191 : }
192 :
193 : pub trait PdbType {
194 : #[doc(hidden)]
195 : fn get_base(&self) -> &ffi::PDB_Type;
196 : }
197 :
198 : impl PdbType for Type<'_> {
199 0 : fn get_base(&self) -> &ffi::PDB_Type {
200 0 : match &self {
201 0 : Type::Simple(ty) => {
202 0 : ty.get_base()
203 : }
204 0 : Type::Array(ty) => {
205 0 : ty.get_base()
206 : }
207 0 : Type::BitField(ty) => {
208 0 : ty.get_base()
209 : }
210 0 : Type::Class(ty) => {
211 0 : ty.get_base()
212 : }
213 0 : Type::Structure(ty) => {
214 0 : ty.get_base()
215 : }
216 0 : Type::Interface(ty) => {
217 0 : ty.get_base()
218 : }
219 0 : Type::Enum(ty) => {
220 0 : ty.get_base()
221 : }
222 0 : Type::Function(ty) => {
223 0 : ty.get_base()
224 : }
225 0 : Type::Modifier(ty) => {
226 0 : ty.get_base()
227 : }
228 0 : Type::Pointer(ty) => {
229 0 : ty.get_base()
230 : }
231 0 : Type::Union(ty) => {
232 0 : ty.get_base()
233 : }
234 0 : Type::Generic(ty) => {
235 0 : ty.get_base()
236 : }
237 : }
238 0 : }
239 : }
240 :
241 : impl PdbType for Generic<'_> {
242 0 : fn get_base(&self) -> &ffi::PDB_Type {
243 0 : self.ptr.as_ref().unwrap()
244 0 : }
245 : }
246 :
247 0 : declare_fwd_iterator!(
248 0 : Types,
249 0 : Type<'a>,
250 0 : ffi::PDB_Type,
251 0 : ffi::PDB_DebugInfo,
252 0 : ffi::PDB_DebugInfo_it_types
253 0 : );
254 :
|
