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