1 // copyright (c) 2020-2021 hors<horsicq@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9
10 // The above copyright notice and this permission notice shall be included in all
11 // copies or substantial portions of the Software.
12
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 // SOFTWARE.
20 //
21 #include "xle.h"
22
XLE(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)23 XLE::XLE(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress) : XMSDOS(pDevice,bIsImage,nModuleAddress)
24 {
25
26 }
27
isValid()28 bool XLE::isValid()
29 {
30 bool bResult=false;
31
32 quint16 magic=get_magic();
33
34 if(magic==XMSDOS_DEF::S_IMAGE_DOS_SIGNATURE_MZ)
35 {
36 qint32 lfanew=get_lfanew();
37
38 if(lfanew>0)
39 {
40 quint16 signature=read_uint16(lfanew);
41
42 if((signature==XLE_DEF::S_IMAGE_VXD_SIGNATURE)||(signature==XLE_DEF::S_IMAGE_LX_SIGNATURE))
43 {
44 bResult=true;
45 }
46 }
47 }
48
49 return bResult;
50 }
51
isValid(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)52 bool XLE::isValid(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
53 {
54 XLE xle(pDevice,bIsImage,nModuleAddress);
55
56 return xle.isValid();
57 }
58
getMode(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)59 XBinary::MODE XLE::getMode(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
60 {
61 XLE xle(pDevice,bIsImage,nModuleAddress);
62
63 return xle.getMode();
64 }
65
getImageVxdHeaderOffset()66 qint64 XLE::getImageVxdHeaderOffset()
67 {
68 qint64 nResult=get_lfanew();
69
70 if(!_isOffsetValid(nResult))
71 {
72 nResult=-1;
73 }
74
75 return nResult;
76 }
77
getImageVxdHeaderSize()78 qint64 XLE::getImageVxdHeaderSize()
79 {
80 return sizeof(XLE_DEF::IMAGE_VXD_HEADER);
81 }
82
getImageVxdHeader()83 XLE_DEF::IMAGE_VXD_HEADER XLE::getImageVxdHeader()
84 {
85 XLE_DEF::IMAGE_VXD_HEADER result={};
86
87 qint64 nOffset=getImageVxdHeaderOffset();
88
89 if(nOffset!=-1)
90 {
91 result.e32_magic=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_magic));
92 result.e32_border=read_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_border));
93 result.e32_worder=read_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_worder));
94 result.e32_level=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_level));
95 result.e32_cpu=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cpu));
96 result.e32_os=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_os));
97 result.e32_ver=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ver));
98 result.e32_mflags=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mflags));
99 result.e32_mpages=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mpages));
100 result.e32_startobj=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_startobj));
101 result.e32_eip=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_eip));
102 result.e32_stackobj=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_stackobj));
103 result.e32_esp=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_esp));
104 result.e32_pagesize=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesize));
105 result.e32_lastpagesize=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_lastpagesize));
106 result.e32_fixupsize=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsize));
107 result.e32_fixupsum=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsum));
108 result.e32_ldrsize=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsize));
109 result.e32_ldrsum=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsum));
110 result.e32_objtab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objtab));
111 result.e32_objcnt=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objcnt));
112 result.e32_objmap=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objmap));
113 result.e32_itermap=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_itermap));
114 result.e32_rsrctab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrctab));
115 result.e32_rsrccnt=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrccnt));
116 result.e32_restab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_restab));
117 result.e32_enttab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_enttab));
118 result.e32_dirtab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dirtab));
119 result.e32_dircnt=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dircnt));
120 result.e32_fpagetab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fpagetab));
121 result.e32_frectab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_frectab));
122 result.e32_impmod=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmod));
123 result.e32_impmodcnt=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmodcnt));
124 result.e32_impproc=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impproc));
125 result.e32_pagesum=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesum));
126 result.e32_datapage=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_datapage));
127 result.e32_preload=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_preload));
128 result.e32_nrestab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nrestab));
129 result.e32_cbnrestab=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cbnrestab));
130 result.e32_nressum=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nressum));
131 result.e32_autodata=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_autodata));
132 result.e32_debuginfo=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuginfo));
133 result.e32_debuglen=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuglen));
134 result.e32_instpreload=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instpreload));
135 result.e32_instdemand=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instdemand));
136 result.e32_heapsize=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_heapsize));
137 }
138
139 return result;
140 }
141
getImageVxdHeader_magic()142 quint16 XLE::getImageVxdHeader_magic()
143 {
144 quint16 nResult=0;
145
146 qint64 nOffset=getImageVxdHeaderOffset();
147
148 if(nOffset!=-1)
149 {
150 nResult=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_magic));
151 }
152
153 return nResult;
154 }
155
getImageVxdHeader_border()156 quint8 XLE::getImageVxdHeader_border()
157 {
158 quint8 nResult=0;
159
160 qint64 nOffset=getImageVxdHeaderOffset();
161
162 if(nOffset!=-1)
163 {
164 nResult=read_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_border));
165 }
166
167 return nResult;
168 }
169
getImageVxdHeader_worder()170 quint8 XLE::getImageVxdHeader_worder()
171 {
172 quint8 nResult=0;
173
174 qint64 nOffset=getImageVxdHeaderOffset();
175
176 if(nOffset!=-1)
177 {
178 nResult=read_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_worder));
179 }
180
181 return nResult;
182 }
183
getImageVxdHeader_level()184 quint32 XLE::getImageVxdHeader_level()
185 {
186 quint32 nResult=0;
187
188 qint64 nOffset=getImageVxdHeaderOffset();
189
190 if(nOffset!=-1)
191 {
192 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_level));
193 }
194
195 return nResult;
196 }
197
getImageVxdHeader_cpu()198 quint16 XLE::getImageVxdHeader_cpu()
199 {
200 quint16 nResult=0;
201
202 qint64 nOffset=getImageVxdHeaderOffset();
203
204 if(nOffset!=-1)
205 {
206 nResult=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cpu));
207 }
208
209 return nResult;
210 }
211
getImageVxdHeader_os()212 quint16 XLE::getImageVxdHeader_os()
213 {
214 quint16 nResult=0;
215
216 qint64 nOffset=getImageVxdHeaderOffset();
217
218 if(nOffset!=-1)
219 {
220 nResult=read_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_os));
221 }
222
223 return nResult;
224 }
225
getImageVxdHeader_ver()226 quint32 XLE::getImageVxdHeader_ver()
227 {
228 quint32 nResult=0;
229
230 qint64 nOffset=getImageVxdHeaderOffset();
231
232 if(nOffset!=-1)
233 {
234 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ver));
235 }
236
237 return nResult;
238 }
239
getImageVxdHeader_mflags()240 quint32 XLE::getImageVxdHeader_mflags()
241 {
242 quint32 nResult=0;
243
244 qint64 nOffset=getImageVxdHeaderOffset();
245
246 if(nOffset!=-1)
247 {
248 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mflags));
249 }
250
251 return nResult;
252 }
253
getImageVxdHeader_mpages()254 quint32 XLE::getImageVxdHeader_mpages()
255 {
256 quint32 nResult=0;
257
258 qint64 nOffset=getImageVxdHeaderOffset();
259
260 if(nOffset!=-1)
261 {
262 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mpages));
263 }
264
265 return nResult;
266 }
267
getImageVxdHeader_startobj()268 quint32 XLE::getImageVxdHeader_startobj()
269 {
270 quint32 nResult=0;
271
272 qint64 nOffset=getImageVxdHeaderOffset();
273
274 if(nOffset!=-1)
275 {
276 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_startobj));
277 }
278
279 return nResult;
280 }
281
getImageVxdHeader_eip()282 quint32 XLE::getImageVxdHeader_eip()
283 {
284 quint32 nResult=0;
285
286 qint64 nOffset=getImageVxdHeaderOffset();
287
288 if(nOffset!=-1)
289 {
290 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_eip));
291 }
292
293 return nResult;
294 }
295
getImageVxdHeader_stackobj()296 quint32 XLE::getImageVxdHeader_stackobj()
297 {
298 quint32 nResult=0;
299
300 qint64 nOffset=getImageVxdHeaderOffset();
301
302 if(nOffset!=-1)
303 {
304 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_stackobj));
305 }
306
307 return nResult;
308 }
309
getImageVxdHeader_esp()310 quint32 XLE::getImageVxdHeader_esp()
311 {
312 quint32 nResult=0;
313
314 qint64 nOffset=getImageVxdHeaderOffset();
315
316 if(nOffset!=-1)
317 {
318 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_esp));
319 }
320
321 return nResult;
322 }
323
getImageVxdHeader_pagesize()324 quint32 XLE::getImageVxdHeader_pagesize()
325 {
326 quint32 nResult=0;
327
328 qint64 nOffset=getImageVxdHeaderOffset();
329
330 if(nOffset!=-1)
331 {
332 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesize));
333 }
334
335 return nResult;
336 }
337
getImageVxdHeader_lastpagesize()338 quint32 XLE::getImageVxdHeader_lastpagesize()
339 {
340 quint32 nResult=0;
341
342 qint64 nOffset=getImageVxdHeaderOffset();
343
344 if(nOffset!=-1)
345 {
346 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_lastpagesize));
347 }
348
349 return nResult;
350 }
351
getImageVxdHeader_fixupsize()352 quint32 XLE::getImageVxdHeader_fixupsize()
353 {
354 quint32 nResult=0;
355
356 qint64 nOffset=getImageVxdHeaderOffset();
357
358 if(nOffset!=-1)
359 {
360 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsize));
361 }
362
363 return nResult;
364 }
365
getImageVxdHeader_fixupsum()366 quint32 XLE::getImageVxdHeader_fixupsum()
367 {
368 quint32 nResult=0;
369
370 qint64 nOffset=getImageVxdHeaderOffset();
371
372 if(nOffset!=-1)
373 {
374 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsum));
375 }
376
377 return nResult;
378 }
379
getImageVxdHeader_ldrsize()380 quint32 XLE::getImageVxdHeader_ldrsize()
381 {
382 quint32 nResult=0;
383
384 qint64 nOffset=getImageVxdHeaderOffset();
385
386 if(nOffset!=-1)
387 {
388 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsize));
389 }
390
391 return nResult;
392 }
393
getImageVxdHeader_ldrsum()394 quint32 XLE::getImageVxdHeader_ldrsum()
395 {
396 quint32 nResult=0;
397
398 qint64 nOffset=getImageVxdHeaderOffset();
399
400 if(nOffset!=-1)
401 {
402 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsum));
403 }
404
405 return nResult;
406 }
407
getImageVxdHeader_objtab()408 quint32 XLE::getImageVxdHeader_objtab()
409 {
410 quint32 nResult=0;
411
412 qint64 nOffset=getImageVxdHeaderOffset();
413
414 if(nOffset!=-1)
415 {
416 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objtab));
417 }
418
419 return nResult;
420 }
421
getImageVxdHeader_objcnt()422 quint32 XLE::getImageVxdHeader_objcnt()
423 {
424 quint32 nResult=0;
425
426 qint64 nOffset=getImageVxdHeaderOffset();
427
428 if(nOffset!=-1)
429 {
430 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objcnt));
431 }
432
433 return nResult;
434 }
435
getImageVxdHeader_objmap()436 quint32 XLE::getImageVxdHeader_objmap()
437 {
438 quint32 nResult=0;
439
440 qint64 nOffset=getImageVxdHeaderOffset();
441
442 if(nOffset!=-1)
443 {
444 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objmap));
445 }
446
447 return nResult;
448 }
449
getImageVxdHeader_itermap()450 quint32 XLE::getImageVxdHeader_itermap()
451 {
452 quint32 nResult=0;
453
454 qint64 nOffset=getImageVxdHeaderOffset();
455
456 if(nOffset!=-1)
457 {
458 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_itermap));
459 }
460
461 return nResult;
462 }
463
getImageVxdHeader_rsrctab()464 quint32 XLE::getImageVxdHeader_rsrctab()
465 {
466 quint32 nResult=0;
467
468 qint64 nOffset=getImageVxdHeaderOffset();
469
470 if(nOffset!=-1)
471 {
472 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrctab));
473 }
474
475 return nResult;
476 }
477
getImageVxdHeader_rsrccnt()478 quint32 XLE::getImageVxdHeader_rsrccnt()
479 {
480 quint32 nResult=0;
481
482 qint64 nOffset=getImageVxdHeaderOffset();
483
484 if(nOffset!=-1)
485 {
486 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrccnt));
487 }
488
489 return nResult;
490 }
491
getImageVxdHeader_restab()492 quint32 XLE::getImageVxdHeader_restab()
493 {
494 quint32 nResult=0;
495
496 qint64 nOffset=getImageVxdHeaderOffset();
497
498 if(nOffset!=-1)
499 {
500 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_restab));
501 }
502
503 return nResult;
504 }
505
getImageVxdHeader_enttab()506 quint32 XLE::getImageVxdHeader_enttab()
507 {
508 quint32 nResult=0;
509
510 qint64 nOffset=getImageVxdHeaderOffset();
511
512 if(nOffset!=-1)
513 {
514 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_enttab));
515 }
516
517 return nResult;
518 }
519
getImageVxdHeader_dirtab()520 quint32 XLE::getImageVxdHeader_dirtab()
521 {
522 quint32 nResult=0;
523
524 qint64 nOffset=getImageVxdHeaderOffset();
525
526 if(nOffset!=-1)
527 {
528 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dirtab));
529 }
530
531 return nResult;
532 }
533
getImageVxdHeader_dircnt()534 quint32 XLE::getImageVxdHeader_dircnt()
535 {
536 quint32 nResult=0;
537
538 qint64 nOffset=getImageVxdHeaderOffset();
539
540 if(nOffset!=-1)
541 {
542 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dircnt));
543 }
544
545 return nResult;
546 }
547
getImageVxdHeader_fpagetab()548 quint32 XLE::getImageVxdHeader_fpagetab()
549 {
550 quint32 nResult=0;
551
552 qint64 nOffset=getImageVxdHeaderOffset();
553
554 if(nOffset!=-1)
555 {
556 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fpagetab));
557 }
558
559 return nResult;
560 }
561
getImageVxdHeader_frectab()562 quint32 XLE::getImageVxdHeader_frectab()
563 {
564 quint32 nResult=0;
565
566 qint64 nOffset=getImageVxdHeaderOffset();
567
568 if(nOffset!=-1)
569 {
570 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_frectab));
571 }
572
573 return nResult;
574 }
575
getImageVxdHeader_impmod()576 quint32 XLE::getImageVxdHeader_impmod()
577 {
578 quint32 nResult=0;
579
580 qint64 nOffset=getImageVxdHeaderOffset();
581
582 if(nOffset!=-1)
583 {
584 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmod));
585 }
586
587 return nResult;
588 }
589
getImageVxdHeader_impmodcnt()590 quint32 XLE::getImageVxdHeader_impmodcnt()
591 {
592 quint32 nResult=0;
593
594 qint64 nOffset=getImageVxdHeaderOffset();
595
596 if(nOffset!=-1)
597 {
598 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmodcnt));
599 }
600
601 return nResult;
602 }
603
getImageVxdHeader_impproc()604 quint32 XLE::getImageVxdHeader_impproc()
605 {
606 quint32 nResult=0;
607
608 qint64 nOffset=getImageVxdHeaderOffset();
609
610 if(nOffset!=-1)
611 {
612 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impproc));
613 }
614
615 return nResult;
616 }
617
getImageVxdHeader_pagesum()618 quint32 XLE::getImageVxdHeader_pagesum()
619 {
620 quint32 nResult=0;
621
622 qint64 nOffset=getImageVxdHeaderOffset();
623
624 if(nOffset!=-1)
625 {
626 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesum));
627 }
628
629 return nResult;
630 }
631
getImageVxdHeader_datapage()632 quint32 XLE::getImageVxdHeader_datapage()
633 {
634 quint32 nResult=0;
635
636 qint64 nOffset=getImageVxdHeaderOffset();
637
638 if(nOffset!=-1)
639 {
640 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_datapage));
641 }
642
643 return nResult;
644 }
645
getImageVxdHeader_preload()646 quint32 XLE::getImageVxdHeader_preload()
647 {
648 quint32 nResult=0;
649
650 qint64 nOffset=getImageVxdHeaderOffset();
651
652 if(nOffset!=-1)
653 {
654 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_preload));
655 }
656
657 return nResult;
658 }
659
getImageVxdHeader_nrestab()660 quint32 XLE::getImageVxdHeader_nrestab()
661 {
662 quint32 nResult=0;
663
664 qint64 nOffset=getImageVxdHeaderOffset();
665
666 if(nOffset!=-1)
667 {
668 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nrestab));
669 }
670
671 return nResult;
672 }
673
getImageVxdHeader_cbnrestab()674 quint32 XLE::getImageVxdHeader_cbnrestab()
675 {
676 quint32 nResult=0;
677
678 qint64 nOffset=getImageVxdHeaderOffset();
679
680 if(nOffset!=-1)
681 {
682 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cbnrestab));
683 }
684
685 return nResult;
686 }
687
getImageVxdHeader_nressum()688 quint32 XLE::getImageVxdHeader_nressum()
689 {
690 quint32 nResult=0;
691
692 qint64 nOffset=getImageVxdHeaderOffset();
693
694 if(nOffset!=-1)
695 {
696 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nressum));
697 }
698
699 return nResult;
700 }
701
getImageVxdHeader_autodata()702 quint32 XLE::getImageVxdHeader_autodata()
703 {
704 quint32 nResult=0;
705
706 qint64 nOffset=getImageVxdHeaderOffset();
707
708 if(nOffset!=-1)
709 {
710 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_autodata));
711 }
712
713 return nResult;
714 }
715
getImageVxdHeader_debuginfo()716 quint32 XLE::getImageVxdHeader_debuginfo()
717 {
718 quint32 nResult=0;
719
720 qint64 nOffset=getImageVxdHeaderOffset();
721
722 if(nOffset!=-1)
723 {
724 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuginfo));
725 }
726
727 return nResult;
728 }
729
getImageVxdHeader_debuglen()730 quint32 XLE::getImageVxdHeader_debuglen()
731 {
732 quint32 nResult=0;
733
734 qint64 nOffset=getImageVxdHeaderOffset();
735
736 if(nOffset!=-1)
737 {
738 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuglen));
739 }
740
741 return nResult;
742 }
743
getImageVxdHeader_instpreload()744 quint32 XLE::getImageVxdHeader_instpreload()
745 {
746 quint32 nResult=0;
747
748 qint64 nOffset=getImageVxdHeaderOffset();
749
750 if(nOffset!=-1)
751 {
752 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instpreload));
753 }
754
755 return nResult;
756 }
757
getImageVxdHeader_instdemand()758 quint32 XLE::getImageVxdHeader_instdemand()
759 {
760 quint32 nResult=0;
761
762 qint64 nOffset=getImageVxdHeaderOffset();
763
764 if(nOffset!=-1)
765 {
766 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instdemand));
767 }
768
769 return nResult;
770 }
771
getImageVxdHeader_heapsize()772 quint32 XLE::getImageVxdHeader_heapsize()
773 {
774 quint32 nResult=0;
775
776 qint64 nOffset=getImageVxdHeaderOffset();
777
778 if(nOffset!=-1)
779 {
780 nResult=read_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_heapsize));
781 }
782
783 return nResult;
784 }
785
setImageVxdHeader_magic(quint16 nValue)786 void XLE::setImageVxdHeader_magic(quint16 nValue)
787 {
788 qint64 nOffset=getImageVxdHeaderOffset();
789
790 if(nOffset!=-1)
791 {
792 write_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_magic),nValue);
793 }
794 }
795
setImageVxdHeader_border(quint8 nValue)796 void XLE::setImageVxdHeader_border(quint8 nValue)
797 {
798 qint64 nOffset=getImageVxdHeaderOffset();
799
800 if(nOffset!=-1)
801 {
802 write_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_border),nValue);
803 }
804 }
805
setImageVxdHeader_worder(quint8 nValue)806 void XLE::setImageVxdHeader_worder(quint8 nValue)
807 {
808 qint64 nOffset=getImageVxdHeaderOffset();
809
810 if(nOffset!=-1)
811 {
812 write_uint8(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_worder),nValue);
813 }
814 }
815
setImageVxdHeader_level(quint32 nValue)816 void XLE::setImageVxdHeader_level(quint32 nValue)
817 {
818 qint64 nOffset=getImageVxdHeaderOffset();
819
820 if(nOffset!=-1)
821 {
822 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_level),nValue);
823 }
824 }
825
setImageVxdHeader_cpu(quint16 nValue)826 void XLE::setImageVxdHeader_cpu(quint16 nValue)
827 {
828 qint64 nOffset=getImageVxdHeaderOffset();
829
830 if(nOffset!=-1)
831 {
832 write_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cpu),nValue);
833 }
834 }
835
setImageVxdHeader_os(quint16 nValue)836 void XLE::setImageVxdHeader_os(quint16 nValue)
837 {
838 qint64 nOffset=getImageVxdHeaderOffset();
839
840 if(nOffset!=-1)
841 {
842 write_uint16(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_os),nValue);
843 }
844 }
845
setImageVxdHeader_ver(quint32 nValue)846 void XLE::setImageVxdHeader_ver(quint32 nValue)
847 {
848 qint64 nOffset=getImageVxdHeaderOffset();
849
850 if(nOffset!=-1)
851 {
852 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ver),nValue);
853 }
854 }
855
setImageVxdHeader_mflags(quint32 nValue)856 void XLE::setImageVxdHeader_mflags(quint32 nValue)
857 {
858 qint64 nOffset=getImageVxdHeaderOffset();
859
860 if(nOffset!=-1)
861 {
862 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mflags),nValue);
863 }
864 }
865
setImageVxdHeader_mpages(quint32 nValue)866 void XLE::setImageVxdHeader_mpages(quint32 nValue)
867 {
868 qint64 nOffset=getImageVxdHeaderOffset();
869
870 if(nOffset!=-1)
871 {
872 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_mpages),nValue);
873 }
874 }
875
setImageVxdHeader_startobj(quint32 nValue)876 void XLE::setImageVxdHeader_startobj(quint32 nValue)
877 {
878 qint64 nOffset=getImageVxdHeaderOffset();
879
880 if(nOffset!=-1)
881 {
882 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_startobj),nValue);
883 }
884 }
885
setImageVxdHeader_eip(quint32 nValue)886 void XLE::setImageVxdHeader_eip(quint32 nValue)
887 {
888 qint64 nOffset=getImageVxdHeaderOffset();
889
890 if(nOffset!=-1)
891 {
892 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_eip),nValue);
893 }
894 }
895
setImageVxdHeader_stackobj(quint32 nValue)896 void XLE::setImageVxdHeader_stackobj(quint32 nValue)
897 {
898 qint64 nOffset=getImageVxdHeaderOffset();
899
900 if(nOffset!=-1)
901 {
902 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_stackobj),nValue);
903 }
904 }
905
setImageVxdHeader_esp(quint32 nValue)906 void XLE::setImageVxdHeader_esp(quint32 nValue)
907 {
908 qint64 nOffset=getImageVxdHeaderOffset();
909
910 if(nOffset!=-1)
911 {
912 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_esp),nValue);
913 }
914 }
915
setImageVxdHeader_pagesize(quint32 nValue)916 void XLE::setImageVxdHeader_pagesize(quint32 nValue)
917 {
918 qint64 nOffset=getImageVxdHeaderOffset();
919
920 if(nOffset!=-1)
921 {
922 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesize),nValue);
923 }
924 }
925
setImageVxdHeader_lastpagesize(quint32 nValue)926 void XLE::setImageVxdHeader_lastpagesize(quint32 nValue)
927 {
928 qint64 nOffset=getImageVxdHeaderOffset();
929
930 if(nOffset!=-1)
931 {
932 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_lastpagesize),nValue);
933 }
934 }
935
setImageVxdHeader_fixupsize(quint32 nValue)936 void XLE::setImageVxdHeader_fixupsize(quint32 nValue)
937 {
938 qint64 nOffset=getImageVxdHeaderOffset();
939
940 if(nOffset!=-1)
941 {
942 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsize),nValue);
943 }
944 }
945
setImageVxdHeader_fixupsum(quint32 nValue)946 void XLE::setImageVxdHeader_fixupsum(quint32 nValue)
947 {
948 qint64 nOffset=getImageVxdHeaderOffset();
949
950 if(nOffset!=-1)
951 {
952 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fixupsum),nValue);
953 }
954 }
955
setImageVxdHeader_ldrsize(quint32 nValue)956 void XLE::setImageVxdHeader_ldrsize(quint32 nValue)
957 {
958 qint64 nOffset=getImageVxdHeaderOffset();
959
960 if(nOffset!=-1)
961 {
962 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsize),nValue);
963 }
964 }
965
setImageVxdHeader_ldrsum(quint32 nValue)966 void XLE::setImageVxdHeader_ldrsum(quint32 nValue)
967 {
968 qint64 nOffset=getImageVxdHeaderOffset();
969
970 if(nOffset!=-1)
971 {
972 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_ldrsum),nValue);
973 }
974 }
975
setImageVxdHeader_objtab(quint32 nValue)976 void XLE::setImageVxdHeader_objtab(quint32 nValue)
977 {
978 qint64 nOffset=getImageVxdHeaderOffset();
979
980 if(nOffset!=-1)
981 {
982 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objtab),nValue);
983 }
984 }
985
setImageVxdHeader_objcnt(quint32 nValue)986 void XLE::setImageVxdHeader_objcnt(quint32 nValue)
987 {
988 qint64 nOffset=getImageVxdHeaderOffset();
989
990 if(nOffset!=-1)
991 {
992 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objcnt),nValue);
993 }
994 }
995
setImageVxdHeader_objmap(quint32 nValue)996 void XLE::setImageVxdHeader_objmap(quint32 nValue)
997 {
998 qint64 nOffset=getImageVxdHeaderOffset();
999
1000 if(nOffset!=-1)
1001 {
1002 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_objmap),nValue);
1003 }
1004 }
1005
setImageVxdHeader_itermap(quint32 nValue)1006 void XLE::setImageVxdHeader_itermap(quint32 nValue)
1007 {
1008 qint64 nOffset=getImageVxdHeaderOffset();
1009
1010 if(nOffset!=-1)
1011 {
1012 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_itermap),nValue);
1013 }
1014 }
1015
setImageVxdHeader_rsrctab(quint32 nValue)1016 void XLE::setImageVxdHeader_rsrctab(quint32 nValue)
1017 {
1018 qint64 nOffset=getImageVxdHeaderOffset();
1019
1020 if(nOffset!=-1)
1021 {
1022 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrctab),nValue);
1023 }
1024 }
1025
setImageVxdHeader_rsrccnt(quint32 nValue)1026 void XLE::setImageVxdHeader_rsrccnt(quint32 nValue)
1027 {
1028 qint64 nOffset=getImageVxdHeaderOffset();
1029
1030 if(nOffset!=-1)
1031 {
1032 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_rsrccnt),nValue);
1033 }
1034 }
1035
setImageVxdHeader_restab(quint32 nValue)1036 void XLE::setImageVxdHeader_restab(quint32 nValue)
1037 {
1038 qint64 nOffset=getImageVxdHeaderOffset();
1039
1040 if(nOffset!=-1)
1041 {
1042 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_restab),nValue);
1043 }
1044 }
1045
setImageVxdHeader_enttab(quint32 nValue)1046 void XLE::setImageVxdHeader_enttab(quint32 nValue)
1047 {
1048 qint64 nOffset=getImageVxdHeaderOffset();
1049
1050 if(nOffset!=-1)
1051 {
1052 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_enttab),nValue);
1053 }
1054 }
1055
setImageVxdHeader_dirtab(quint32 nValue)1056 void XLE::setImageVxdHeader_dirtab(quint32 nValue)
1057 {
1058 qint64 nOffset=getImageVxdHeaderOffset();
1059
1060 if(nOffset!=-1)
1061 {
1062 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dirtab),nValue);
1063 }
1064 }
1065
setImageVxdHeader_dircnt(quint32 nValue)1066 void XLE::setImageVxdHeader_dircnt(quint32 nValue)
1067 {
1068 qint64 nOffset=getImageVxdHeaderOffset();
1069
1070 if(nOffset!=-1)
1071 {
1072 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_dircnt),nValue);
1073 }
1074 }
1075
setImageVxdHeader_fpagetab(quint32 nValue)1076 void XLE::setImageVxdHeader_fpagetab(quint32 nValue)
1077 {
1078 qint64 nOffset=getImageVxdHeaderOffset();
1079
1080 if(nOffset!=-1)
1081 {
1082 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_fpagetab),nValue);
1083 }
1084 }
1085
setImageVxdHeader_frectab(quint32 nValue)1086 void XLE::setImageVxdHeader_frectab(quint32 nValue)
1087 {
1088 qint64 nOffset=getImageVxdHeaderOffset();
1089
1090 if(nOffset!=-1)
1091 {
1092 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_frectab),nValue);
1093 }
1094 }
1095
setImageVxdHeader_impmod(quint32 nValue)1096 void XLE::setImageVxdHeader_impmod(quint32 nValue)
1097 {
1098 qint64 nOffset=getImageVxdHeaderOffset();
1099
1100 if(nOffset!=-1)
1101 {
1102 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmod),nValue);
1103 }
1104 }
1105
setImageVxdHeader_impmodcnt(quint32 nValue)1106 void XLE::setImageVxdHeader_impmodcnt(quint32 nValue)
1107 {
1108 qint64 nOffset=getImageVxdHeaderOffset();
1109
1110 if(nOffset!=-1)
1111 {
1112 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impmodcnt),nValue);
1113 }
1114 }
1115
setImageVxdHeader_impproc(quint32 nValue)1116 void XLE::setImageVxdHeader_impproc(quint32 nValue)
1117 {
1118 qint64 nOffset=getImageVxdHeaderOffset();
1119
1120 if(nOffset!=-1)
1121 {
1122 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_impproc),nValue);
1123 }
1124 }
1125
setImageVxdHeader_pagesum(quint32 nValue)1126 void XLE::setImageVxdHeader_pagesum(quint32 nValue)
1127 {
1128 qint64 nOffset=getImageVxdHeaderOffset();
1129
1130 if(nOffset!=-1)
1131 {
1132 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_pagesum),nValue);
1133 }
1134 }
1135
setImageVxdHeader_datapage(quint32 nValue)1136 void XLE::setImageVxdHeader_datapage(quint32 nValue)
1137 {
1138 qint64 nOffset=getImageVxdHeaderOffset();
1139
1140 if(nOffset!=-1)
1141 {
1142 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_datapage),nValue);
1143 }
1144 }
1145
setImageVxdHeader_preload(quint32 nValue)1146 void XLE::setImageVxdHeader_preload(quint32 nValue)
1147 {
1148 qint64 nOffset=getImageVxdHeaderOffset();
1149
1150 if(nOffset!=-1)
1151 {
1152 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_preload),nValue);
1153 }
1154 }
1155
setImageVxdHeader_nrestab(quint32 nValue)1156 void XLE::setImageVxdHeader_nrestab(quint32 nValue)
1157 {
1158 qint64 nOffset=getImageVxdHeaderOffset();
1159
1160 if(nOffset!=-1)
1161 {
1162 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nrestab),nValue);
1163 }
1164 }
1165
setImageVxdHeader_cbnrestab(quint32 nValue)1166 void XLE::setImageVxdHeader_cbnrestab(quint32 nValue)
1167 {
1168 qint64 nOffset=getImageVxdHeaderOffset();
1169
1170 if(nOffset!=-1)
1171 {
1172 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_cbnrestab),nValue);
1173 }
1174 }
1175
setImageVxdHeader_nressum(quint32 nValue)1176 void XLE::setImageVxdHeader_nressum(quint32 nValue)
1177 {
1178 qint64 nOffset=getImageVxdHeaderOffset();
1179
1180 if(nOffset!=-1)
1181 {
1182 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_nressum),nValue);
1183 }
1184 }
1185
setImageVxdHeader_autodata(quint32 nValue)1186 void XLE::setImageVxdHeader_autodata(quint32 nValue)
1187 {
1188 qint64 nOffset=getImageVxdHeaderOffset();
1189
1190 if(nOffset!=-1)
1191 {
1192 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_autodata),nValue);
1193 }
1194 }
1195
setImageVxdHeader_debuginfo(quint32 nValue)1196 void XLE::setImageVxdHeader_debuginfo(quint32 nValue)
1197 {
1198 qint64 nOffset=getImageVxdHeaderOffset();
1199
1200 if(nOffset!=-1)
1201 {
1202 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuginfo),nValue);
1203 }
1204 }
1205
setImageVxdHeader_debuglen(quint32 nValue)1206 void XLE::setImageVxdHeader_debuglen(quint32 nValue)
1207 {
1208 qint64 nOffset=getImageVxdHeaderOffset();
1209
1210 if(nOffset!=-1)
1211 {
1212 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_debuglen),nValue);
1213 }
1214 }
1215
setImageVxdHeader_instpreload(quint32 nValue)1216 void XLE::setImageVxdHeader_instpreload(quint32 nValue)
1217 {
1218 qint64 nOffset=getImageVxdHeaderOffset();
1219
1220 if(nOffset!=-1)
1221 {
1222 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instpreload),nValue);
1223 }
1224 }
1225
setImageVxdHeader_instdemand(quint32 nValue)1226 void XLE::setImageVxdHeader_instdemand(quint32 nValue)
1227 {
1228 qint64 nOffset=getImageVxdHeaderOffset();
1229
1230 if(nOffset!=-1)
1231 {
1232 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_instdemand),nValue);
1233 }
1234 }
1235
setImageVxdHeader_heapsize(quint32 nValue)1236 void XLE::setImageVxdHeader_heapsize(quint32 nValue)
1237 {
1238 qint64 nOffset=getImageVxdHeaderOffset();
1239
1240 if(nOffset!=-1)
1241 {
1242 write_uint32(nOffset+offsetof(XLE_DEF::IMAGE_VXD_HEADER,e32_heapsize),nValue);
1243 }
1244 }
1245
_read_o32_obj(qint64 nOffset)1246 XLE_DEF::o32_obj XLE::_read_o32_obj(qint64 nOffset)
1247 {
1248 XLE_DEF::o32_obj result={};
1249
1250 result.o32_size=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_size));
1251 result.o32_base=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_base));
1252 result.o32_flags=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_flags));
1253 result.o32_pagemap=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_pagemap));
1254 result.o32_mapsize=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_mapsize));
1255 result.o32_reserved=read_uint32(nOffset+offsetof(XLE_DEF::o32_obj,o32_reserved));
1256
1257 return result;
1258 }
1259
_read_o32_map(qint64 nOffset)1260 XLE_DEF::o32_map XLE::_read_o32_map(qint64 nOffset)
1261 {
1262 XLE_DEF::o32_map result={};
1263
1264 result.o32_pagedataoffset=read_uint32(nOffset+offsetof(XLE_DEF::o32_map,o32_pagedataoffset));
1265 result.o32_pagesize=read_uint32(nOffset+offsetof(XLE_DEF::o32_map,o32_pagesize));
1266 result.o32_pageflags=read_uint32(nOffset+offsetof(XLE_DEF::o32_map,o32_pageflags));
1267
1268 return result;
1269 }
1270
getObjects()1271 QList<XLE_DEF::o32_obj> XLE::getObjects()
1272 {
1273 QList<XLE_DEF::o32_obj> listResult;
1274
1275 qint64 nObjOffset=getImageVxdHeaderOffset()+getImageVxdHeader_objtab();
1276 quint32 nNumberOfObjects=getImageVxdHeader_objcnt();
1277
1278 for(quint32 i=0;i<nNumberOfObjects;i++)
1279 {
1280 XLE_DEF::o32_obj record=_read_o32_obj(nObjOffset);
1281
1282 listResult.append(record);
1283
1284 nObjOffset+=sizeof(XLE_DEF::o32_obj);
1285 }
1286
1287 return listResult;
1288 }
1289
getMaps()1290 QList<XLE_DEF::o32_map> XLE::getMaps()
1291 {
1292 QList<XLE_DEF::o32_map> listResult;
1293
1294 qint64 nMapOffset=getImageVxdHeaderOffset()+getImageVxdHeader_objmap();
1295 quint32 nNumberOfMaps=getImageVxdHeader_itermap();
1296
1297 for(quint32 i=0;i<nNumberOfMaps;i++)
1298 {
1299 XLE_DEF::o32_map record=_read_o32_map(nMapOffset);
1300
1301 listResult.append(record);
1302
1303 nMapOffset+=sizeof(XLE_DEF::o32_map);
1304 }
1305
1306 return listResult;
1307 }
1308
getMemoryMap()1309 XBinary::_MEMORY_MAP XLE::getMemoryMap()
1310 {
1311 XBinary::_MEMORY_MAP result={};
1312
1313 result.sArch=getArch();
1314 result.mode=getMode();
1315 result.bIsBigEndian=isBigEndian();
1316 result.sType=getTypeAsString();
1317 result.fileType=getFileType();
1318
1319 result.nRawSize=getSize();
1320 // TODO Image size CONST
1321 // TODO Image Base
1322 // result.nImageSize=0xFFFF;
1323
1324 QList<XLE_DEF::o32_map> listMaps=XLE::getMaps(); // TODO Check
1325
1326 QList<XLE_DEF::o32_obj> listObjects=XLE::getObjects();
1327
1328 int nNumberOfObjects=listObjects.count();
1329
1330 for(int i=0;i<nNumberOfObjects;i++)
1331 {
1332 // TODO
1333 }
1334
1335 return result;
1336 }
1337
getMode()1338 XBinary::MODE XLE::getMode()
1339 {
1340 MODE result=MODE_16SEG;
1341
1342 qint32 lfanew=get_lfanew();
1343 quint16 signature=read_uint16(lfanew);
1344
1345 if(signature==XLE_DEF::S_IMAGE_VXD_SIGNATURE)
1346 {
1347 result=MODE_16SEG;
1348 }
1349 else if(signature==XLE_DEF::S_IMAGE_LX_SIGNATURE)
1350 {
1351 result=MODE_32;
1352 }
1353
1354 return result;
1355 }
1356
getArch()1357 QString XLE::getArch()
1358 {
1359 return getImageLECpusS().value(getImageVxdHeader_cpu(),QString("UNKNOWN"));
1360 }
1361
isBigEndian()1362 bool XLE::isBigEndian()
1363 {
1364 return false;
1365 }
1366
getEntryPointOffset(XBinary::_MEMORY_MAP * pMemoryMap)1367 qint64 XLE::getEntryPointOffset(XBinary::_MEMORY_MAP *pMemoryMap)
1368 {
1369 Q_UNUSED(pMemoryMap)
1370 // TODO
1371 // Check !!!
1372 // startobj:eip
1373 return 0;
1374 }
1375
getFileType()1376 XBinary::FT XLE::getFileType()
1377 {
1378 FT result=FT_LE;
1379
1380 MODE mode=getMode();
1381
1382 if(mode==MODE_16SEG)
1383 {
1384 result=FT_LE;
1385 }
1386 else if(mode==MODE_32)
1387 {
1388 result=FT_LX;
1389 }
1390
1391 return result;
1392 }
1393
getType()1394 int XLE::getType()
1395 {
1396 return TYPE_EXE; // TODO
1397 }
1398
typeIdToString(int nType)1399 QString XLE::typeIdToString(int nType)
1400 {
1401 QString sResult="Unknown"; // mb TODO translate
1402
1403 switch(nType)
1404 {
1405 case TYPE_UNKNOWN: sResult=QString("Unknown"); break; // mb TODO translate
1406 case TYPE_EXE: sResult=QString("EXE"); break;
1407 }
1408
1409 return sResult;
1410 }
1411
getImageLEMagics()1412 QMap<quint64, QString> XLE::getImageLEMagics()
1413 {
1414 QMap<quint64, QString> mapResult;
1415
1416 mapResult.insert(0x454C,"IMAGE_VXD_SIGNATURE");
1417 mapResult.insert(0x584C,"IMAGE_LX_SIGNATURE");
1418
1419 return mapResult;
1420 }
1421
getImageLEMagicsS()1422 QMap<quint64, QString> XLE::getImageLEMagicsS()
1423 {
1424 QMap<quint64, QString> mapResult;
1425
1426 mapResult.insert(0x454C,"VXD_SIGNATURE");
1427 mapResult.insert(0x584C,"LX_SIGNATURE");
1428
1429 return mapResult;
1430 }
1431
getImageLECpusS()1432 QMap<quint64, QString> XLE::getImageLECpusS()
1433 {
1434 QMap<quint64, QString> mapResult;
1435
1436 mapResult.insert(0x01,"80286");
1437 mapResult.insert(0x02,"80386");
1438 mapResult.insert(0x03,"80486");
1439 mapResult.insert(0x04,"80586");
1440 mapResult.insert(0x20,"i860");
1441 mapResult.insert(0x21,"N11");
1442 mapResult.insert(0x40,"R2000");
1443 mapResult.insert(0x41,"R6000");
1444 mapResult.insert(0x42,"R4000");
1445
1446 return mapResult;
1447 }
1448
getImageLEOssS()1449 QMap<quint64, QString> XLE::getImageLEOssS()
1450 {
1451 QMap<quint64, QString> mapResult;
1452
1453 mapResult.insert(0x00,"Unknown (any new-format OS)");
1454 mapResult.insert(0x01,"OS/2 (default)");
1455 mapResult.insert(0x02,"Windows");
1456 mapResult.insert(0x03,"DOS 4.x");
1457 mapResult.insert(0x04,"Windows 386");
1458
1459 return mapResult;
1460 }
1461
getImageLEMflagsS()1462 QMap<quint64, QString> XLE::getImageLEMflagsS()
1463 {
1464 QMap<quint64, QString> mapResult;
1465
1466 // TODO
1467
1468 return mapResult;
1469 }
1470