?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedump: Add print_string() helper.
[wine.git] / tools / winedump / tlb.c
blobd2883598d7b44aa3418c53d0d1d710df535e4bdb
1 /*
2 * Dump a typelib (tlb) file
3 *
4 * Copyright 2006 Jacek Caban
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "windef.h"
29
30 #include "winedump.h"
31
32 #define MSFT_MAGIC 0x5446534d
33 #define HELPDLLFLAG 0x0100
34
35 enum TYPEKIND {
36 TKIND_ENUM = 0,
37 TKIND_RECORD,
38 TKIND_MODULE,
39 TKIND_INTERFACE,
40 TKIND_DISPATCH,
41 TKIND_COCLASS,
42 TKIND_ALIAS,
43 TKIND_UNION,
44 TKIND_MAX
45 };
46
47 enum VARENUM {
48 VT_EMPTY = 0,
49 VT_NULL = 1,
50 VT_I2 = 2,
51 VT_I4 = 3,
52 VT_R4 = 4,
53 VT_R8 = 5,
54 VT_CY = 6,
55 VT_DATE = 7,
56 VT_BSTR = 8,
57 VT_DISPATCH = 9,
58 VT_ERROR = 10,
59 VT_BOOL = 11,
60 VT_VARIANT = 12,
61 VT_UNKNOWN = 13,
62 VT_DECIMAL = 14,
63 VT_I1 = 16,
64 VT_UI1 = 17,
65 VT_UI2 = 18,
66 VT_UI4 = 19,
67 VT_I8 = 20,
68 VT_UI8 = 21,
69 VT_INT = 22,
70 VT_UINT = 23,
71 VT_VOID = 24,
72 VT_HRESULT = 25,
73 VT_PTR = 26,
74 VT_SAFEARRAY = 27,
75 VT_CARRAY = 28,
76 VT_USERDEFINED = 29,
77 VT_LPSTR = 30,
78 VT_LPWSTR = 31,
79 VT_RECORD = 36,
80 VT_INT_PTR = 37,
81 VT_UINT_PTR = 38,
82 VT_FILETIME = 64,
83 VT_BLOB = 65,
84 VT_STREAM = 66,
85 VT_STORAGE = 67,
86 VT_STREAMED_OBJECT = 68,
87 VT_STORED_OBJECT = 69,
88 VT_BLOB_OBJECT = 70,
89 VT_CF = 71,
90 VT_CLSID = 72,
91 VT_VERSIONED_STREAM = 73,
92 VT_BSTR_BLOB = 0xfff,
93 VT_VECTOR = 0x1000,
94 VT_ARRAY = 0x2000,
95 VT_BYREF = 0x4000,
96 VT_RESERVED = 0x8000,
97 VT_ILLEGAL = 0xffff,
98 VT_ILLEGALMASKED = 0xfff,
99 VT_TYPEMASK = 0xfff
100 };
101
102 struct seg_t;
103
104 typedef BOOL (*dump_seg_t)(struct seg_t*);
105
106 typedef struct seg_t {
107 const char *name;
108 dump_seg_t func;
109 int offset;
110 int length;
111 } seg_t;
112 static seg_t segdir[15];
113
114 enum SEGDIRTYPE {
115 SEGDIR_TYPEINFO,
116 SEGDIR_IMPINFO,
117 SEGDIR_IMPFILES,
118 SEGDIR_REF,
119 SEGDIR_GUIDHASH,
120 SEGDIR_GUID,
121 SEGDIR_NAMEHASH,
122 SEGDIR_NAME,
123 SEGDIR_STRING,
124 SEGDIR_TYPEDESC,
125 SEGDIR_ARRAYDESC,
126 SEGDIR_CUSTDATA,
127 SEGDIR_CDGUID,
128 SEGDIR_res0e,
129 SEGDIR_res0f
130 };
131
132 static int offset=0;
133 static int indent;
134 static int typeinfo_cnt;
135 static int header_flags = 0;
136 static BOOL msft_eof = FALSE;
137
138 static int msft_typeinfo_offs[1000];
139 static int msft_typeinfo_kind[1000];
140 static int msft_typeinfo_impltypes[1000];
141 static int msft_typeinfo_elemcnt[1000];
142 static int msft_typeinfo_cnt = 0;
143
144 static const void *tlb_read(int size) {
145 const void *ret = PRD(offset, size);
146
147 if(ret)
148 offset += size;
149 else
150 msft_eof = TRUE;
151
152 return ret;
153 }
154
155 static int tlb_read_int(void)
156 {
157 const int *ret = tlb_read(sizeof(int));
158 return ret ? *ret : -1;
159 }
160
161 static int tlb_read_short(void)
162 {
163 const unsigned short *ret = tlb_read(sizeof(short));
164 return ret ? *ret : -1;
165 }
166
167 static int tlb_read_byte(void)
168 {
169 const unsigned char *ret = tlb_read(sizeof(char));
170 return ret ? *ret : -1;
171 }
172
173 static void print_offset(void)
174 {
175 int i;
176 for(i=0; i<indent; i++)
177 printf(" ");
178 }
179
180 static void print_begin_block(const char *name)
181 {
182 print_offset();
183 printf("%s {\n", name);
184 indent++;
185 }
186
187 static void print_begin_block_id(const char *name, int id)
188 {
189 char buf[64];
190 sprintf(buf, "%s %d", name, id);
191 print_begin_block(buf);
192 }
193
194 static void print_end_block(void)
195 {
196 indent--;
197 print_offset();
198 printf("}\n");
199 print_offset();
200 printf("\n");
201 }
202
203 static int print_hex(const char *name)
204 {
205 int ret;
206 print_offset();
207 printf("%s = %08xh\n", name, ret=tlb_read_int());
208 return ret;
209 }
210
211 static int print_hex_id(const char *name, int id)
212 {
213 char buf[64];
214 sprintf(buf, name, id);
215 return print_hex(buf);
216 }
217
218 static int print_short_hex(const char *name)
219 {
220 int ret;
221 print_offset();
222 printf("%s = %04xh\n", name, ret=tlb_read_short());
223 return ret;
224 }
225
226 static int print_dec(const char *name)
227 {
228 int ret;
229 print_offset();
230 printf("%s = %d\n", name, ret=tlb_read_int());
231 return ret;
232 }
233
234 static void print_guid(const char *name)
235 {
236 GUID guid = *(const GUID*)tlb_read(sizeof(guid));
237
238 print_offset();
239
240 printf("%s = {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n", name,
241 guid.Data1, guid.Data2, guid.Data3, guid.Data4[0],
242 guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4],
243 guid.Data4[5], guid.Data4[6], guid.Data4[7]);
244 }
245
246 static void print_vartype(int vartype)
247 {
248 static const char *vartypes[VT_LPWSTR+1] = {
249 "VT_EMPTY", "VT_NULL", "VT_I2", "VT_I4", "VT_R4",
250 "VT_R8", "VT_CY", "VT_DATE", "VT_BSTR", "VT_DISPATCH",
251 "VT_ERROR", "VT_BOOL", "VT_VARIANT", "VT_UNKNOWN","VT_DECIMAL",
252 "unk 15", "VT_I1", "VT_UI1", "VT_UI2", "VT_UI4",
253 "VT_I8", "VT_UI8", "VT_INT", "VT_UINT", "VT_VOID",
254 "VT_HRESULT", "VT_PTR", "VT_SAFEARRAY","VT_CARRAY", "VT_USERDEFINED",
255 "VT_LPSTR", "VT_LPWSTR"
256 };
257
258 vartype &= VT_TYPEMASK;
259 if (vartype >= VT_EMPTY && vartype <= VT_LPWSTR)
260 printf("%s\n", vartypes[vartype]);
261 else
262 printf("unk %d\n", vartype);
263 }
264
265 static void print_ctl2(const char *name)
266 {
267 int len;
268 const char *buf;
269
270 print_offset();
271
272 len = tlb_read_short();
273
274 printf("%s = %d \"", name, len);
275 len >>= 2;
276 buf = tlb_read(len);
277 fwrite(buf, len, 1, stdout);
278 printf("\"");
279 len += 2;
280
281 while(len++ & 3)
282 printf("\\%02x", tlb_read_byte());
283 printf("\n");
284 }
285
286 static void dump_binary(int n)
287 {
288 int i;
289
290 for(i = 1; i <= n; i++) {
291 switch(i & 0x0f) {
292 case 0:
293 printf("%02x\n", tlb_read_byte());
294 break;
295 case 1:
296 print_offset();
297 /* fall through */
298 default:
299 printf("%02x ", tlb_read_byte());
300 }
301 }
302
303 if(n&0x0f)
304 printf("\n");
305 }
306
307 static int dump_msft_varflags(void)
308 {
309 static const char *syskind[] = {
310 "SYS_WIN16", "SYS_WIN32", "SYS_MAC", "SYS_WIN64", "unknown"
311 };
312 int kind, flags;
313
314 print_offset();
315 flags = tlb_read_int();
316 kind = flags & 0xf;
317 if (kind > 3) kind = 4;
318 printf("varflags = %08x, syskind = %s\n", flags, syskind[kind]);
319 return flags;
320 }
321
322 static void dump_msft_version(void)
323 {
324 unsigned version;
325 print_offset();
326 version = tlb_read_int();
327 printf("version = %u.%u\n", version & 0xffff, version >> 16);
328 }
329
330 static void dump_msft_header(void)
331 {
332 print_begin_block("Header");
333
334 print_hex("magic1");
335 print_hex("magic2");
336 print_hex("posguid");
337 print_hex("lcid");
338 print_hex("lcid2");
339 header_flags = dump_msft_varflags();
340 dump_msft_version();
341 print_hex("flags");
342 typeinfo_cnt = print_dec("ntypeinfos");
343 print_dec("helpstring");
344 print_dec("helpstringcontext");
345 print_dec("helpcontext");
346 print_dec("nametablecount");
347 print_dec("nametablechars");
348 print_hex("NameOffset");
349 print_hex("helpfile");
350 print_hex("CustomDataOffset");
351 print_hex("res44");
352 print_hex("res48");
353 print_hex("dispatchpos");
354 print_hex("res50");
355
356 print_end_block();
357 }
358
359 static int dump_msft_typekind(void)
360 {
361 static const char *tkind[TKIND_MAX] = {
362 "TKIND_ENUM", "TKIND_RECORD", "TKIND_MODULE",
363 "TKIND_INTERFACE", "TKIND_DISPATCH", "TKIND_COCLASS",
364 "TKIND_ALIAS", "TKIND_UNION"
365 };
366 int ret, typekind;
367
368 print_offset();
369 ret = tlb_read_int();
370 typekind = ret & 0xf;
371 printf("typekind = %s, align = %d\n", typekind < TKIND_MAX ? tkind[typekind] : "unknown", (ret >> 11) & 0x1f);
372 return ret;
373 }
374
375 static void dump_msft_typeinfobase(void)
376 {
377 print_begin_block_id("TypeInfoBase", msft_typeinfo_cnt);
378
379 msft_typeinfo_kind[msft_typeinfo_cnt] = dump_msft_typekind();
380 msft_typeinfo_offs[msft_typeinfo_cnt] = print_hex("memoffset");
381 print_hex("res2");
382 print_hex("res3");
383 print_hex("res4");
384 print_hex("res5");
385 msft_typeinfo_elemcnt[msft_typeinfo_cnt] = print_hex("cElement");
386 print_hex("res7");
387 print_hex("res8");
388 print_hex("res9");
389 print_hex("resA");
390 print_hex("posguid");
391 print_hex("flags");
392 print_hex("NameOffset");
393 print_hex("version");
394 print_hex("docstringoffs");
395 print_hex("docstringcontext");
396 print_hex("helpcontext");
397 print_hex("oCustData");
398 msft_typeinfo_impltypes[msft_typeinfo_cnt++] = print_short_hex("cImplTypes");
399 print_short_hex("bSizeVftt");
400 print_dec("size");
401 print_hex("datatype1");
402 print_hex("datatype2");
403 print_hex("res18");
404 print_hex("res19");
405
406 print_end_block();
407 }
408
409 static BOOL dump_msft_typeinfobases(seg_t *seg)
410 {
411 int i;
412
413 for(i = 0; offset < seg->offset+seg->length; i++)
414 dump_msft_typeinfobase();
415
416 assert(offset == seg->offset+seg->length);
417 return TRUE;
418 }
419
420 static void dump_msft_impinfo(int n)
421 {
422 print_begin_block_id("ImpInfo", n);
423
424 print_hex("flags");
425 print_hex("oImpInfo");
426 print_hex("oGuid");
427
428 print_end_block();
429 }
430
431 static BOOL dump_msft_impinfos(seg_t *seg)
432 {
433 int i;
434
435 for(i = 0; offset < seg->offset+seg->length; i++)
436 dump_msft_impinfo(i);
437
438 assert(offset == seg->offset+seg->length);
439 return TRUE;
440 }
441
442 static void dump_msft_impfile(int n)
443 {
444 print_begin_block_id("ImpFile", n);
445
446 print_hex("guid");
447 print_hex("lcid");
448 print_hex("version");
449 print_ctl2("impfile");
450
451 print_end_block();
452 }
453
454 static BOOL dump_msft_impfiles(seg_t *seg)
455 {
456 int i;
457
458 for(i = 0; offset < seg->offset+seg->length; i++)
459 dump_msft_impfile(i);
460
461 assert(offset == seg->offset+seg->length);
462 return TRUE;
463 }
464
465 static BOOL dump_msft_reftabs(seg_t *seg)
466 {
467 print_begin_block("RefTab");
468
469 dump_binary(seg->length); /* FIXME */
470
471 print_end_block();
472
473 return TRUE;
474 }
475
476 static BOOL dump_msft_guidhashtab(seg_t *seg)
477 {
478 print_begin_block("GuidHashTab");
479
480 dump_binary(seg->length); /* FIXME */
481
482 print_end_block();
483
484 assert(offset == seg->offset+seg->length);
485 return TRUE;
486 }
487
488 static void dump_msft_guidentry(int n)
489 {
490 print_begin_block_id("GuidEntry", n);
491
492 print_guid("guid");
493 print_hex("hreftype");
494 print_hex("next_hash");
495
496 print_end_block();
497 }
498
499 static BOOL dump_msft_guidtab(seg_t *seg)
500 {
501 int i;
502
503 for(i = 0; offset < seg->offset+seg->length; i++)
504 dump_msft_guidentry(i);
505
506 assert(offset == seg->offset+seg->length);
507 return TRUE;
508 }
509
510 static BOOL dump_msft_namehashtab(seg_t *seg)
511 {
512 print_begin_block("NameHashTab");
513
514 dump_binary(seg->length); /* FIXME */
515
516 print_end_block();
517 return TRUE;
518 }
519
520 static void print_string(int len)
521 {
522 printf("\"");
523 fwrite(tlb_read(len), len, 1, stdout);
524 printf("\"");
525 }
526
527 static void dump_string(int len, int align_off)
528 {
529 print_string(len);
530 printf(" ");
531 while((len++ + align_off) & 3)
532 printf("\\%2.2x", tlb_read_byte());
533 }
534
535 static void dump_msft_name(int base, int n)
536 {
537 int len;
538
539 print_begin_block_id("Name", n);
540
541 print_hex("hreftype");
542 print_hex("next_hash");
543 len = print_hex("namelen")&0xff;
544
545 print_offset();
546 printf("name = ");
547 dump_string(len, 0);
548 printf("\n");
549
550 print_end_block();
551 }
552
553 static BOOL dump_msft_nametab(seg_t *seg)
554 {
555 int i, base = offset;
556
557 for(i = 0; offset < seg->offset+seg->length; i++)
558 dump_msft_name(base, i);
559
560 assert(offset == seg->offset+seg->length);
561 return TRUE;
562 }
563
564 static void dump_msft_string(int n)
565 {
566 int len;
567
568 print_begin_block_id("String", n);
569
570 len = print_short_hex("stringlen");
571
572 print_offset();
573 printf("string = ");
574 dump_string(len, 2);
575
576 if(len < 3) {
577 for(len = 0; len < 4; len++)
578 printf("\\%2.2x", tlb_read_byte());
579 }
580 printf("\n");
581
582 print_end_block();
583 }
584
585 static BOOL dump_msft_stringtab(seg_t *seg)
586 {
587 int i;
588
589 for(i = 0; offset < seg->offset+seg->length; i++)
590 dump_msft_string(i);
591
592 assert(offset == seg->offset+seg->length);
593 return TRUE;
594 }
595
596 static void dump_msft_typedesc(int n)
597 {
598 print_begin_block_id("TYPEDESC", n);
599
600 print_hex("hreftype");
601 print_hex("vt");
602
603 print_end_block();
604 }
605
606 static BOOL dump_msft_typedesctab(seg_t *seg)
607 {
608 int i;
609
610 print_begin_block("TypedescTab");
611
612 for(i = 0; offset < seg->offset+seg->length; i++)
613 dump_msft_typedesc(i);
614
615 print_end_block();
616
617 assert(offset == seg->offset+seg->length);
618 return TRUE;
619 }
620
621 static BOOL dump_msft_arraydescs(seg_t *seg)
622 {
623 print_begin_block("ArrayDescriptions");
624
625 dump_binary(seg->length); /* FIXME */
626
627 print_end_block();
628 return TRUE;
629 }
630
631 static BOOL dump_msft_custdata(seg_t *seg)
632 {
633 unsigned short vt;
634 unsigned i, n;
635
636 print_begin_block("CustData");
637
638 for(i=0; offset < seg->offset+seg->length; i++) {
639 print_offset();
640
641 vt = tlb_read_short();
642 printf("vt %d", vt);
643 n = tlb_read_int();
644
645 switch(vt) {
646 case VT_BSTR:
647 printf(" len %d: ", n);
648 dump_string(n, 2);
649 printf("\n");
650 break;
651 default:
652 printf(": %x ", n);
653 printf("\\%2.2x ", tlb_read_byte());
654 printf("\\%2.2x\n", tlb_read_byte());
655 }
656 }
657
658 print_end_block();
659 return TRUE;
660 }
661
662 static void dump_msft_cdguid(int n)
663 {
664 print_begin_block_id("CGUid", n);
665
666 print_hex("GuidOffset");
667 print_hex("DataOffset");
668 print_hex("next");
669
670 print_end_block();
671 }
672
673 static BOOL dump_msft_cdguids(seg_t *seg)
674 {
675 int i;
676
677 for(i = 0; offset < seg->offset+seg->length; i++)
678 dump_msft_cdguid(i);
679
680 assert(offset == seg->offset+seg->length);
681 return TRUE;
682 }
683
684 static BOOL dump_msft_res0e(seg_t *seg)
685 {
686 print_begin_block("res0e");
687 dump_binary(seg->length);
688 print_end_block();
689
690 return TRUE;
691 }
692
693 static BOOL dump_msft_res0f(seg_t *seg)
694 {
695 print_begin_block("res0f");
696 dump_binary(seg->length);
697 print_end_block();
698
699 return TRUE;
700 }
701
702 /* Used for function return value and arguments type */
703 static void dump_msft_datatype(const char *name)
704 {
705 int datatype;
706
707 print_offset();
708 datatype = tlb_read_int();
709 printf("%s = %08x", name, datatype);
710 if (datatype < 0) {
711 printf(", ");
712 print_vartype(datatype);
713 }
714 else {
715 const short *vt;
716
717 if (datatype > segdir[SEGDIR_TYPEDESC].length) {
718 printf(", invalid offset\n");
719 return;
720 }
721
722 /* FIXME: in case of VT_USERDEFINED use hreftype */
723 vt = PRD(segdir[SEGDIR_TYPEDESC].offset + datatype, 4*sizeof(short));
724 datatype = vt[0] & VT_TYPEMASK;
725 if (datatype == VT_PTR) {
726 printf(", VT_PTR -> ");
727 if (vt[3] < 0)
728 datatype = vt[2];
729 else {
730 vt = PRD(segdir[SEGDIR_TYPEDESC].offset + vt[2], 4*sizeof(short));
731 datatype = *vt;
732 }
733 }
734 else {
735 printf(", ");
736 datatype = *vt;
737 }
738
739 print_vartype(datatype);
740 }
741 }
742
743 static void dump_defaultvalue(int id)
744 {
745 int offset;
746
747 print_offset();
748 offset = tlb_read_int();
749
750 printf("default value[%d] = %08x", id, offset);
751 if (offset == -1)
752 printf("\n");
753 else if (offset < 0) {
754 printf(", ");
755 print_vartype((offset & 0x7c000000) >> 26);
756 }
757 else {
758 const unsigned short *vt;
759
760 if (offset > segdir[SEGDIR_CUSTDATA].length) {
761 printf(", invalid offset\n");
762 return;
763 }
764
765 vt = PRD(segdir[SEGDIR_CUSTDATA].offset + offset, sizeof(*vt));
766 printf(", ");
767 print_vartype(*vt);
768 }
769 }
770
771 static void dump_msft_func(int n)
772 {
773 int size, args_cnt, i, extra_attr, fkccic;
774
775 print_begin_block_id("FuncRecord", n);
776
777 size = print_short_hex("size");
778 print_short_hex("index");
779 dump_msft_datatype("retval type");
780 print_hex("flags");
781 print_short_hex("VtableOffset");
782 print_short_hex("funcdescsize");
783 fkccic = print_hex("FKCCIC");
784 args_cnt = print_short_hex("nrargs");
785 print_short_hex("noptargs");
786
787 extra_attr = size/sizeof(INT) - 6 - args_cnt*(fkccic&0x1000 ? 4 : 3);
788
789 if(extra_attr)
790 print_hex("helpcontext");
791 if(extra_attr >= 2)
792 print_hex("oHelpString");
793 if(extra_attr >= 3)
794 print_hex("toEntry");
795 if(extra_attr >= 4)
796 print_hex("res9");
797 if(extra_attr >= 5)
798 print_hex("resA");
799 if(extra_attr >= 6)
800 print_hex("HelpStringContext");
801 if(extra_attr >= 7)
802 print_hex("oCustData");
803 for(i = 0; i < extra_attr-7; i++)
804 print_hex_id("oArgCustData", i);
805
806 if(fkccic & 0x1000) {
807 for(i=0; i < args_cnt; i++)
808 dump_defaultvalue(i);
809 }
810
811 for(i=0; i < args_cnt; i++) {
812 print_begin_block_id("param", i);
813
814 /* FIXME: Handle default values */
815 dump_msft_datatype("datatype");
816 print_hex("name");
817 print_hex("paramflags");
818
819 print_end_block();
820 }
821
822 print_end_block();
823 }
824
825 static void dump_msft_var(int n)
826 {
827 INT size;
828
829 print_begin_block_id("VarRecord", n);
830
831 size = print_hex("recsize")&0x1ff;
832 print_hex("DataType");
833 print_hex("flags");
834 print_short_hex("VarKind");
835 print_short_hex("vardescsize");
836 print_hex("OffsValue");
837
838 if(size > 5*sizeof(INT))
839 dump_binary(size - 5*sizeof(INT));
840
841 print_end_block();
842 }
843
844 static void dump_msft_ref(int n)
845 {
846 print_begin_block_id("RefRecord", n);
847
848 print_hex("reftype");
849 print_hex("flags");
850 print_hex("oCustData");
851 print_hex("onext");
852
853 print_end_block();
854 }
855
856 static void dump_msft_coclass(int n)
857 {
858 int i;
859
860 print_dec("size");
861
862 for(i=0; i < msft_typeinfo_impltypes[n]; i++)
863 dump_msft_ref(i);
864 }
865
866 static BOOL dump_msft_typeinfo(int n)
867 {
868 int i;
869
870 print_begin_block_id("TypeInfo", n);
871
872 if((msft_typeinfo_kind[n] & 0xf) == TKIND_COCLASS) {
873 dump_msft_coclass(n);
874 print_end_block();
875 return TRUE;
876 }
877
878 print_dec("size");
879
880 for(i = 0; i < LOWORD(msft_typeinfo_elemcnt[n]); i++)
881 dump_msft_func(i);
882
883 for(i = 0; i < HIWORD(msft_typeinfo_elemcnt[n]); i++)
884 dump_msft_var(i);
885
886 for(i = 0; i < LOWORD(msft_typeinfo_elemcnt[n]); i++)
887 print_hex_id("func %d id", i);
888
889 for(i = 0; i < HIWORD(msft_typeinfo_elemcnt[n]); i++)
890 print_hex_id("var %d id", i);
891
892 for(i = 0; i < LOWORD(msft_typeinfo_elemcnt[n]); i++)
893 print_hex_id("func %d name", i);
894
895 for(i = 0; i < HIWORD(msft_typeinfo_elemcnt[n]); i++)
896 print_hex_id("var %d name", i);
897
898 for(i = 0; i < LOWORD(msft_typeinfo_elemcnt[n]); i++)
899 print_hex_id("func %d offset", i);
900
901 for(i = 0; i < HIWORD(msft_typeinfo_elemcnt[n]); i++)
902 print_hex_id("var %d offset", i);
903
904 print_end_block();
905
906 return TRUE;
907 }
908
909 static seg_t segdir[] = {
910 {"TypeInfoTab", dump_msft_typeinfobases, -1, -1},
911 {"ImpInfo", dump_msft_impinfos, -1, -1},
912 {"ImpFiles", dump_msft_impfiles, -1, -1},
913 {"RefTab", dump_msft_reftabs, -1, -1},
914 {"GuidHashTab", dump_msft_guidhashtab, -1, -1},
915 {"GuidTab", dump_msft_guidtab, -1, -1},
916 {"NameHashTab", dump_msft_namehashtab, -1, -1},
917 {"pNameTab", dump_msft_nametab, -1, -1},
918 {"pStringTab", dump_msft_stringtab, -1, -1},
919 {"TypedescTab", dump_msft_typedesctab, -1, -1},
920 {"ArrayDescriptions", dump_msft_arraydescs, -1, -1},
921 {"CustData", dump_msft_custdata, -1, -1},
922 {"CDGuid", dump_msft_cdguids, -1, -1},
923 {"res0e", dump_msft_res0e, -1, -1},
924 {"res0f", dump_msft_res0f, -1, -1}
925 };
926
927 static void dump_msft_seg(seg_t *seg)
928 {
929 print_begin_block(seg->name);
930
931 seg->offset = print_hex("offset");
932 seg->length = print_dec("length");
933 print_hex("res08");
934 print_hex("res0c");
935
936 print_end_block();
937 }
938
939 static void dump_msft_segdir(void)
940 {
941 int i;
942
943 print_begin_block("SegDir");
944
945 for(i=0; i < sizeof(segdir)/sizeof(segdir[0]); i++)
946 dump_msft_seg(segdir+i);
947
948 print_end_block();
949 }
950
951 static BOOL dump_offset(void)
952 {
953 int i;
954
955 for(i=0; i < sizeof(segdir)/sizeof(segdir[0]); i++)
956 if(segdir[i].offset == offset)
957 return segdir[i].func(segdir+i);
958
959 for(i=0; i < msft_typeinfo_cnt; i++)
960 if(msft_typeinfo_offs[i] == offset)
961 return dump_msft_typeinfo(i);
962
963 return FALSE;
964 }
965
966 enum FileSig get_kind_msft(void)
967 {
968 const DWORD *sig = PRD(0, sizeof(DWORD));
969 return sig && *sig == MSFT_MAGIC ? SIG_MSFT : SIG_UNKNOWN;
970 }
971
972 void msft_dump(void)
973 {
974 int i;
975
976 dump_msft_header();
977
978 for(i=0; i < typeinfo_cnt; i++)
979 print_hex_id("typeinfo %d offset", i);
980
981 if(header_flags & HELPDLLFLAG)
982 print_hex("help dll offset");
983 print_offset();
984 printf("\n");
985
986 dump_msft_segdir();
987
988 while(!msft_eof) {
989 if(!dump_offset())
990 print_hex("unknown");
991 }
992 }
Windows API implementation