source: trunk/tools/wrc/dumpres.c@ 22016

Last change on this file since 22016 was 5522, checked in by sandervl, 25 years ago

updates
File size: 24.5 KB
Line 
1/*
2 * Copyrignt 1998 Bertho A. Stultiens (BS)
3 *
4 * 16-Apr-1998 BS - Yeah, dump it to stdout.
5 *
6 */
7
8#include "config.h"
9
10#include <assert.h>
11#include <stdio.h>
12#include <ctype.h>
13
14#include "wrc.h"
15#include "dumpres.h"
16
17/*
18 *****************************************************************************
19 * Function : get_typename
20 * Syntax : char *get_typename(resource_t* r)
21 * Input :
22 * r - Resource description
23 * Output : A pointer to a string representing the resource type
24 * Description :
25 * Remarks :
26 *****************************************************************************
27*/
28char *get_typename(resource_t* r)
29{
30 switch(r->type){
31 case res_acc: return "ACCELERATOR";
32 case res_bmp: return "BITMAP";
33 case res_cur: return "CURSOR";
34 case res_curg: return "GROUP_CURSOR";
35 case res_dlg: return "DIALOG";
36 case res_dlgex: return "DIALOGEX";
37 case res_fnt: return "FONT";
38 case res_ico: return "ICON";
39 case res_icog: return "GROUP_ICON";
40 case res_men: return "MENU";
41 case res_menex: return "MENUEX";
42 case res_rdt: return "RCDATA";
43 case res_stt: return "STRINGTABLE";
44 case res_usr: return "UserResource";
45 case res_msg: return "MESSAGETABLE";
46 case res_ver: return "VERSIONINFO";
47 case res_dlginit: return "DLGINIT";
48 case res_toolbar: return "TOOLBAR";
49 case res_anicur: return "CURSOR (animated)";
50 case res_aniico: return "ICON (animated)";
51 default: return "Unknown";
52 }
53}
54
55/*
56 *****************************************************************************
57 * Function : strncpyWtoA
58 * Syntax : char *strncpyWtoA(char *cs, short *ws, int maxlen)
59 * Input :
60 * cs - Pointer to buffer to receive result
61 * ws - Source wide-string
62 * maxlen - Max chars to copy
63 * Output : 'cs'
64 * Description : Copy a unicode string to ascii. Copying stops after the
65 * first occuring '\0' or when maxlen-1 chars are copied. The
66 * String is always nul terminated.
67 * Remarks : No codepage translation is done.
68 *****************************************************************************
69*/
70char *strncpyWtoA(char *cs, short *ws, int maxlen)
71{
72 char *cptr = cs;
73 short *wsMax = ws + maxlen;
74 while(ws < wsMax)
75 {
76 if(*ws < -128 || *ws > 127)
77 printf("***Warning: Unicode string contains non-printable chars***");
78 *cptr++ = (char)*ws++;
79 maxlen--;
80 }
81 *cptr = '\0';
82 return cs;
83}
84
85/*
86 *****************************************************************************
87 * Function : print_string
88 * Syntax : void print_string(string_t *str)
89 * Input :
90 * Output :
91 * Description :
92 * Remarks :
93 *****************************************************************************
94*/
95void print_string(string_t *str)
96{
97 char buffer[512];
98 if(!str)
99 printf("<none>");
100 else if(str->type == str_char)
101 printf("\"%s\"", str->str.cstr);
102 else
103 {
104 strncpyWtoA(buffer, str->str.wstr, sizeof(buffer));
105 printf("L\"%s\"", buffer);
106 }
107}
108
109/*
110 *****************************************************************************
111 * Function : get_nameid_str
112 * Syntax : char *get_nameid_str(name_id_t *n)
113 * Input :
114 * n - nameid to convert to text
115 * Output : A pointer to the name.
116 * Description :
117 * Remarks : Not reentrant because of static buffer
118 *****************************************************************************
119*/
120char *get_nameid_str(name_id_t *n)
121{
122 static char buffer[256];
123
124 if(!n)
125 return "<none>";
126
127 if(n->type == name_ord)
128 {
129 sprintf(buffer, "%d", n->name.i_name);
130 return buffer;
131 }
132 else if(n->type == name_str)
133 {
134 if(n->name.s_name->type == str_char)
135 return n->name.s_name->str.cstr;
136 else
137 {
138 strncpyWtoA(buffer, n->name.s_name->str.wstr, sizeof(buffer));
139 return buffer;
140 }
141 }
142 else
143 return "Hoooo, report this: wrong type in nameid";
144}
145
146/*
147 *****************************************************************************
148 * Function : dump_memopt
149 * Syntax : void dump_memopt(DWORD memopt)
150 * Input :
151 * memopt - flag bits of the options set
152 * Output :
153 * Description :
154 * Remarks :
155 *****************************************************************************
156*/
157static void dump_memopt(DWORD memopt)
158{
159 printf("Memory/load options: ");
160 if(memopt & 0x0040)
161 printf("PRELOAD ");
162 else
163 printf("LOADONCALL ");
164 if(memopt & 0x0010)
165 printf("MOVEABLE ");
166 else
167 printf("FIXED ");
168 if(memopt & 0x0020)
169 printf("PURE ");
170 else
171 printf("IMPURE ");
172 if(memopt & 0x1000)
173 printf("DISCARDABLE");
174 printf("\n");
175}
176
177/*
178 *****************************************************************************
179 * Function : dump_lvc
180 * Syntax : void dump_lvc(lvc_t *l)
181 * Input :
182 * l - pointer to lvc structure
183 * Output :
184 * Description : Dump language, version and characteristics
185 * Remarks :
186 *****************************************************************************
187*/
188static void dump_lvc(lvc_t *l)
189{
190 if(l->language)
191 printf("LANGUAGE %04x, %04x\n", l->language->id, l->language->sub);
192 else
193 printf("LANGUAGE <not set>\n");
194
195 if(l->version)
196 printf("VERSION %08lx\n", *(l->version));
197 else
198 printf("VERSION <not set>\n");
199
200 if(l->characts)
201 printf("CHARACTERISTICS %08lx\n", *(l->characts));
202 else
203 printf("CHARACTERISTICS <not set>\n");
204}
205
206/*
207 *****************************************************************************
208 * Function : dump_raw_data
209 * Syntax : void dump_raw_data(raw_data_t *d)
210 * Input :
211 * d - Raw data descriptor
212 * Output :
213 * Description :
214 * Remarks :
215 *****************************************************************************
216*/
217static void dump_raw_data(raw_data_t *d)
218{
219 unsigned int n;
220 int i;
221 int j;
222
223 if(!d)
224 {
225 printf("<none>");
226 return;
227 }
228 printf("Rawdata size: %d\n", d->size);
229 if(debuglevel < 2)
230 return;
231
232 for(n = 0; n < d->size; n++)
233 {
234 if((n % 16) == 0)
235 {
236 if(n)
237 {
238 printf("- ");
239 for(i = 0; i < 16; i++)
240 printf("%c", isprint(d->data[n-16+i] & 0xff) ? d->data[n-16+i] : '.');
241 printf("\n%08x: ", n);
242 }
243 else
244 printf("%08x: ", n);
245 }
246 printf("%02x ", d->data[n] & 0xff);
247 }
248 printf("- ");
249 j = d->size % 16;
250 if(!j)
251 j = 16;
252 for(i = 0; i < j; i++)
253 printf("%c", isprint(d->data[n-j+i] & 0xff) ? d->data[n-j+i] : '.');
254 printf("\n");
255}
256
257/*
258 *****************************************************************************
259 * Function : dump_accelerator
260 * Syntax : void dump_accelerator(resource_t *acc)
261 * Input :
262 * acc - Accelerator resource descriptor
263 * Output : nop
264 * Description :
265 * Remarks :
266 *****************************************************************************
267*/
268static void dump_accelerator(accelerator_t *acc)
269{
270 event_t *ev = acc->events;
271
272 dump_memopt(acc->memopt);
273 dump_lvc(&(acc->lvc));
274
275 printf("Events: %s\n", ev ? "" : "<none>");
276 while(ev)
277 {
278 printf("Key=");
279 if(isprint(ev->key))
280 printf("\"%c\"", ev->key);
281 else if(iscntrl(ev->key))
282 printf("\"^%c\"", ev->key +'@');
283 else
284 printf("\\x%02x", ev->key & 0xff);
285
286 printf(" Id=%d flags=%04x\n", ev->id, ev->flags);
287 ev = ev->next;
288 }
289}
290
291/*
292 *****************************************************************************
293 * Function : dump_cursor
294 * Syntax : void dump_cursor(cursor_t *cur)
295 * Input :
296 * cur - Cursor resource descriptor
297 * Output : nop
298 * Description :
299 * Remarks :
300 *****************************************************************************
301*/
302static void dump_cursor(cursor_t *cur)
303{
304 printf("Id: %d\n", cur->id);
305 printf("Width: %d\n", cur->width);
306 printf("Height: %d\n", cur->height);
307 printf("X Hotspot: %d\n", cur->xhot);
308 printf("Y Hotspot: %d\n", cur->yhot);
309 dump_raw_data(cur->data);
310}
311
312/*
313 *****************************************************************************
314 * Function : dump_cursor_group
315 * Syntax : void dump_cursor_group(cursor_group_t *cur)
316 * Input :
317 * cur - Cursor group resource descriptor
318 * Output : nop
319 * Description :
320 * Remarks :
321 *****************************************************************************
322*/
323static void dump_cursor_group(cursor_group_t *curg)
324{
325 dump_memopt(curg->memopt);
326 printf("There are %d cursors in this group\n", curg->ncursor);
327}
328
329/*
330 *****************************************************************************
331 * Function : dump_icon
332 * Syntax : void dump_icon(icon_t *ico)
333 * Input :
334 * ico - Icon resource descriptor
335 * Output : nop
336 * Description :
337 * Remarks :
338 *****************************************************************************
339*/
340static void dump_icon(icon_t *ico)
341{
342 printf("Id: %d\n", ico->id);
343 printf("Width: %d\n", ico->width);
344 printf("Height: %d\n", ico->height);
345 printf("NColor: %d\n", ico->nclr);
346 printf("NPlanes: %d\n", ico->planes);
347 printf("NBits: %d\n", ico->bits);
348 dump_raw_data(ico->data);
349}
350
351/*
352 *****************************************************************************
353 * Function : dump_icon_group
354 * Syntax : void dump_icon_group(icon_group_t *ico)
355 * Input :
356 * ico - Icon group resource descriptor
357 * Output : nop
358 * Description :
359 * Remarks :
360 *****************************************************************************
361*/
362static void dump_icon_group(icon_group_t *icog)
363{
364 dump_memopt(icog->memopt);
365 printf("There are %d icons in this group\n", icog->nicon);
366}
367
368/*
369 *****************************************************************************
370 * Function : dump_ani_curico
371 * Syntax : void dump_ani_curico(ani_curico_t *ani)
372 * Input :
373 * ani - Animated object resource descriptor
374 * Output : nop
375 * Description :
376 * Remarks :
377 *****************************************************************************
378*/
379static void dump_ani_curico(ani_curico_t *ani)
380{
381 dump_memopt(ani->memopt);
382 dump_lvc(&ani->data->lvc);
383 dump_raw_data(ani->data);
384}
385
386/*
387 *****************************************************************************
388 * Function : dump_font
389 * Syntax : void dump_font(font_t *fnt)
390 * Input :
391 * fnt - Font resource descriptor
392 * Output : nop
393 * Description :
394 * Remarks :
395 *****************************************************************************
396*/
397static void dump_font(font_t *fnt)
398{
399 dump_memopt(fnt->memopt);
400 dump_lvc(&(fnt->data->lvc));
401 dump_raw_data(fnt->data);
402}
403
404/*
405 *****************************************************************************
406 * Function : dump_bitmap
407 * Syntax : void dump_bitmap(bitmap_t *bmp)
408 * Input :
409 * bmp - Bitmap resource descriptor
410 * Output : nop
411 * Description :
412 * Remarks :
413 *****************************************************************************
414*/
415static void dump_bitmap(bitmap_t *bmp)
416{
417 dump_memopt(bmp->memopt);
418 dump_lvc(&(bmp->data->lvc));
419 dump_raw_data(bmp->data);
420}
421
422/*
423 *****************************************************************************
424 * Function : dump_rcdata
425 * Syntax : void dump_rcdata(rcdata_t *rdt)
426 * Input :
427 * rdt - RCData resource descriptor
428 * Output : nop
429 * Description :
430 * Remarks :
431 *****************************************************************************
432*/
433static void dump_rcdata(rcdata_t *rdt)
434{
435 dump_memopt(rdt->memopt);
436 dump_lvc(&(rdt->data->lvc));
437 dump_raw_data(rdt->data);
438}
439
440/*
441 *****************************************************************************
442 * Function : dump_user
443 * Syntax : void dump_user(user_t *usr)
444 * Input :
445 * usr - User resource descriptor
446 * Output : nop
447 * Description :
448 * Remarks :
449 *****************************************************************************
450*/
451static void dump_user(user_t *usr)
452{
453 dump_memopt(usr->memopt);
454 dump_lvc(&(usr->data->lvc));
455 printf("Class %s\n", get_nameid_str(usr->type));
456 dump_raw_data(usr->data);
457}
458
459/*
460 *****************************************************************************
461 * Function : dump_messagetable
462 * Syntax : void dump_messagetable(messagetable_t *msg)
463 * Input :
464 * msg - Messagetable resource descriptor
465 * Output : nop
466 * Description :
467 * Remarks :
468 *****************************************************************************
469*/
470static void dump_messagetable(messagetable_t *msg)
471{
472 dump_memopt(msg->memopt);
473 dump_lvc(&(msg->data->lvc));
474 dump_raw_data(msg->data);
475}
476
477/*
478 *****************************************************************************
479 * Function : dump_stringtable
480 * Syntax : void dump_stringtable(stringtable_t *stt)
481 * Input :
482 * stt - Stringtable resource descriptor
483 * Output : nop
484 * Description :
485 * Remarks :
486 *****************************************************************************
487*/
488static void dump_stringtable(stringtable_t *stt)
489{
490 int i;
491 for(; stt; stt = stt->next)
492 {
493 printf("{\n");
494 dump_memopt(stt->memopt);
495 dump_lvc(&(stt->lvc));
496 for(i = 0; i < stt->nentries; i++)
497 {
498 printf("Id=%-5d (%d) ", stt->idbase+i, stt->entries[i].id);
499 if(stt->entries[i].str)
500 print_string(stt->entries[i].str);
501 else
502 printf("<none>");
503 printf("\n");
504 }
505 printf("}\n");
506 }
507}
508
509/*
510 *****************************************************************************
511 * Function : dump_control
512 * Syntax : void dump_control(control_t *ctrl)
513 * Input :
514 * ctrl - Control resource descriptor
515 * Output :
516 * Description :
517 * Remarks :
518 *****************************************************************************
519*/
520static void dump_control(control_t *ctrl)
521{
522 printf("Control {\n\tClass: %s\n", get_nameid_str(ctrl->ctlclass));
523 printf("\tText: "); get_nameid_str(ctrl->title); printf("\n");
524 printf("\tId: %d\n", ctrl->id);
525 printf("\tx, y, w, h: %d, %d, %d, %d\n", ctrl->x, ctrl->y, ctrl->width, ctrl->height);
526 if(ctrl->gotstyle)
527 {
528 assert(ctrl->style != NULL);
529 assert(ctrl->style->and_mask == 0);
530 printf("\tStyle: %08lx\n", ctrl->style->or_mask);
531 }
532 if(ctrl->gotexstyle)
533 {
534 assert(ctrl->exstyle != NULL);
535 assert(ctrl->exstyle->and_mask == 0);
536 printf("\tExStyle: %08lx\n", ctrl->exstyle->or_mask);
537 }
538 if(ctrl->gothelpid)
539 printf("\tHelpid: %ld\n", ctrl->helpid);
540 if(ctrl->extra)
541 {
542 printf("\t");
543 dump_raw_data(ctrl->extra);
544 }
545 printf("}\n");
546}
547
548/*
549 *****************************************************************************
550 * Function : dump_dialog
551 * Syntax : void dump_dialog(dialog_t *dlg)
552 * Input :
553 * dlg - Dialog resource descriptor
554 * Output :
555 * Description :
556 * Remarks :
557 *****************************************************************************
558*/
559static void dump_dialog(dialog_t *dlg)
560{
561 control_t *c = dlg->controls;
562
563 dump_memopt(dlg->memopt);
564 dump_lvc(&(dlg->lvc));
565 printf("x, y, w, h: %d, %d, %d, %d\n", dlg->x, dlg->y, dlg->width, dlg->height);
566 if(dlg->gotstyle)
567 {
568 assert(dlg->style != NULL);
569 assert(dlg->style->and_mask == 0);
570 printf("Style: %08lx\n", dlg->style->or_mask);
571
572 }
573 if(dlg->gotexstyle)
574 {
575 assert(dlg->exstyle != NULL);
576 assert(dlg->exstyle->and_mask == 0);
577 printf("ExStyle: %08lx\n", dlg->exstyle->or_mask);
578 }
579 printf("Menu: %s\n", get_nameid_str(dlg->menu));
580 printf("Class: %s\n", get_nameid_str(dlg->dlgclass));
581 printf("Title: "); print_string(dlg->title); printf("\n");
582 printf("Font: ");
583 if(!dlg->font)
584 printf("<none>\n");
585 else
586 {
587 printf("%d, ", dlg->font->size);
588 print_string(dlg->font->name);
589 printf("\n");
590 }
591 while(c)
592 {
593 dump_control(c);
594 c = c->next;
595 }
596}
597
598/*
599 *****************************************************************************
600 * Function : dump_dialogex
601 * Syntax : void dump_dialogex(dialogex_t *dlgex)
602 * Input :
603 * dlgex - DialogEx resource descriptor
604 * Output :
605 * Description :
606 * Remarks :
607 *****************************************************************************
608*/
609static void dump_dialogex(dialogex_t *dlgex)
610{
611 control_t *c = dlgex->controls;
612
613 dump_memopt(dlgex->memopt);
614 dump_lvc(&(dlgex->lvc));
615 printf("x, y, w, h: %d, %d, %d, %d\n", dlgex->x, dlgex->y, dlgex->width, dlgex->height);
616 if(dlgex->gotstyle)
617 {
618 assert(dlgex->style != NULL);
619 assert(dlgex->style->and_mask == 0);
620 printf("Style: %08lx\n", dlgex->style->or_mask);
621 }
622 if(dlgex->gotexstyle)
623 {
624 assert(dlgex->exstyle != NULL);
625 assert(dlgex->exstyle->and_mask == 0);
626 printf("ExStyle: %08lx\n", dlgex->exstyle->or_mask);
627 }
628 if(dlgex->gothelpid)
629 printf("Helpid: %ld\n", dlgex->helpid);
630 printf("Menu: %s\n", get_nameid_str(dlgex->menu));
631 printf("Class: %s\n", get_nameid_str(dlgex->dlgclass));
632 printf("Title: "); print_string(dlgex->title); printf("\n");
633 printf("Font: ");
634 if(!dlgex->font)
635 printf("<none>\n");
636 else
637 {
638 printf("%d, ", dlgex->font->size);
639 print_string(dlgex->font->name);
640 printf(", %d, %d\n", dlgex->font->weight, dlgex->font->italic);
641 }
642 while(c)
643 {
644 dump_control(c);
645 c = c->next;
646 }
647}
648
649/*
650 *****************************************************************************
651 * Function : dump_menu_item
652 * Syntax : void dump_menu_item(menu_item_t *item)
653 * Input :
654 * Output :
655 * Description :
656 * Remarks :
657 *****************************************************************************
658*/
659static void dump_menu_item(menu_item_t *item)
660{
661 while(item)
662 {
663 if(item->popup)
664 {
665 printf("POPUP ");
666 print_string(item->name);
667 printf("\n");
668 dump_menu_item(item->popup);
669 }
670 else
671 {
672 printf("MENUITEM ");
673 if(item->name)
674 {
675 print_string(item->name);
676 printf(", %d, %08lx", item->id, item->state);
677 }
678 else
679 printf("SEPARATOR");
680 printf("\n");
681 }
682 item = item->next;
683 }
684}
685
686/*
687 *****************************************************************************
688 * Function : dump_menu
689 * Syntax : void dump_menu(menu_t *men)
690 * Input :
691 * men - Menu resource descriptor
692 * Output :
693 * Description :
694 * Remarks :
695 *****************************************************************************
696*/
697static void dump_menu(menu_t *men)
698{
699 dump_memopt(men->memopt);
700 dump_lvc(&(men->lvc));
701 dump_menu_item(men->items);
702}
703
704/*
705 *****************************************************************************
706 * Function : dump_menuex_item
707 * Syntax : void dump_menuex_item(menuex_item_t *item)
708 * Input :
709 * Output :
710 * Description :
711 * Remarks :
712 *****************************************************************************
713*/
714static void dump_menuex_item(menuex_item_t *item)
715{
716 while(item)
717 {
718 if(item->popup)
719 {
720 printf("POPUP ");
721 print_string(item->name);
722 if(item->gotid)
723 printf(", Id=%d", item->id);
724 if(item->gottype)
725 printf(", Type=%ld", item->type);
726 if(item->gotstate)
727 printf(", State=%08lx", item->state);
728 if(item->gothelpid)
729 printf(", HelpId=%d", item->helpid);
730 printf("\n");
731 dump_menuex_item(item->popup);
732 }
733 else
734 {
735 printf("MENUITEM ");
736 if(item->name)
737 {
738 print_string(item->name);
739 if(item->gotid)
740 printf(", Id=%d", item->id);
741 if(item->gottype)
742 printf(", Type=%ld", item->type);
743 if(item->gotstate)
744 printf(", State=%08lx", item->state);
745 if(item->gothelpid)
746 printf(", HelpId=%d", item->helpid);
747 }
748 else
749 printf("SEPARATOR");
750 printf("\n");
751 }
752 item = item->next;
753 }
754}
755
756/*
757 *****************************************************************************
758 * Function : dump_menuex
759 * Syntax : void dump_menuex(dialogex_t *menex)
760 * Input :
761 * menex - MenuEx resource descriptor
762 * Output :
763 * Description :
764 * Remarks :
765 *****************************************************************************
766*/
767static void dump_menuex(menuex_t *menex)
768{
769 dump_memopt(menex->memopt);
770 dump_lvc(&(menex->lvc));
771 dump_menuex_item(menex->items);
772}
773
774/*
775 *****************************************************************************
776 * Function : dump_ver_value
777 * Syntax : void dump_ver_value(ver_value_t *val)
778 * Input :
779 * Output :
780 * Description :
781 * Remarks :
782 *****************************************************************************
783*/
784static void dump_ver_block(ver_block_t *); /* Forward ref */
785
786static void dump_ver_value(ver_value_t *val)
787{
788 if(val->type == val_str)
789 {
790 printf("VALUE ");
791 print_string(val->key);
792 printf(" ");
793 print_string(val->value.str);
794 printf("\n");
795 }
796 else if(val->type == val_words)
797 {
798 int i;
799 printf("VALUE");
800 print_string(val->key);
801 for(i = 0; i < val->value.words->nwords; i++)
802 printf(" %04x", val->value.words->words[i]);
803 printf("\n");
804 }
805 else if(val->type == val_block)
806 {
807 dump_ver_block(val->value.block);
808 }
809}
810
811/*
812 *****************************************************************************
813 * Function : dump_ver_block
814 * Syntax : void dump_ver_block(ver_block_t *blk)
815 * Input :
816 * Output :
817 * Description :
818 * Remarks :
819 *****************************************************************************
820*/
821static void dump_ver_block(ver_block_t *blk)
822{
823 ver_value_t *val = blk->values;
824 printf("BLOCK ");
825 print_string(blk->name);
826 printf("\n{\n");
827 while(val)
828 {
829 dump_ver_value(val);
830 val = val->next;
831 }
832 printf("}\n");
833}
834
835/*
836 *****************************************************************************
837 * Function : dump_versioninfo
838 * Syntax : void dump_versioninfo(versioninfo_t *ver)
839 * Input :
840 * ver - Versioninfo resource descriptor
841 * Output :
842 * Description :
843 * Remarks :
844 *****************************************************************************
845*/
846static void dump_versioninfo(versioninfo_t *ver)
847{
848 ver_block_t *blk = ver->blocks;
849
850 dump_lvc(&(ver->lvc));
851
852 if(ver->gotit.fv)
853 printf("FILEVERSION %04x, %04x, %04x, %04x\n",
854 ver->filever_maj1,
855 ver->filever_maj2,
856 ver->filever_min1,
857 ver->filever_min2);
858 if(ver->gotit.pv)
859 printf("PRODUCTVERSION %04x, %04x, %04x, %04x\n",
860 ver->prodver_maj1,
861 ver->prodver_maj2,
862 ver->prodver_min1,
863 ver->prodver_min2);
864 if(ver->gotit.fo)
865 printf("FILEOS %08x\n", ver->fileos);
866 if(ver->gotit.ff)
867 printf("FILEFLAGS %08x\n", ver->fileflags);
868 if(ver->gotit.ffm)
869 printf("FILEFLAGSMASK %08x\n", ver->fileflagsmask);
870 if(ver->gotit.ft)
871 printf("FILETYPE %08x\n", ver->filetype);
872 if(ver->gotit.fst)
873 printf("FILESUBTYPE %08x\n", ver->filesubtype);
874 while(blk)
875 {
876 dump_ver_block(blk);
877 blk = blk->next;
878 }
879}
880
881/*
882 *****************************************************************************
883 * Function : dump_toolbar_item
884 * Syntax : void dump_toolbar_item(toolbar_item_t *item)
885 * Input :
886 * Output :
887 * Description :
888 * Remarks :
889 *****************************************************************************
890*/
891static void dump_toolbar_items(toolbar_item_t *items)
892{
893 while(items)
894 {
895 if(items->id)
896 printf(" BUTTON %d", items->id );
897 else
898 printf(" SEPARATOR");
899
900 printf("\n");
901
902 items = items->next;
903 }
904}
905
906/*
907 *****************************************************************************
908 * Function : dump_toolbar
909 * Syntax : void dump_toolbar(toolbar_t *toolbar)
910 * Input :
911 * toolbar - Toolbar resource descriptor
912 * Output :
913 * Description :
914 * Remarks :
915 *****************************************************************************
916*/
917static void dump_toolbar(toolbar_t *toolbar)
918{
919 dump_memopt(toolbar->memopt);
920 dump_lvc(&(toolbar->lvc));
921 dump_toolbar_items(toolbar->items);
922}
923
924/*
925 *****************************************************************************
926 * Function : dump_dlginit
927 * Syntax : void dump_dlginit(dlginit_t *dit)
928 * Input :
929 * dit - DlgInit resource descriptor
930 * Output :
931 * Description :
932 * Remarks :
933 *****************************************************************************
934*/
935static void dump_dlginit(dlginit_t *dit)
936{
937 dump_memopt(dit->memopt);
938 dump_lvc(&(dit->data->lvc));
939 dump_raw_data(dit->data);
940}
941
942/*
943 *****************************************************************************
944 * Function :
945 * Syntax :
946 * Input :
947 * Output :
948 * Description :
949 * Remarks :
950 *****************************************************************************
951*/
952/*
953 *****************************************************************************
954 * Function : dump_resources
955 * Syntax : void dump_resources(resource_t *top)
956 * Input :
957 * top - Top of the resource tree
958 * Output :
959 * nop
960 * Description : Dump the parsed resource-tree to stdout
961 * Remarks :
962 *****************************************************************************
963*/
964void dump_resources(resource_t *top)
965{
966 printf("Internal resource-tree dump:\n");
967 while(top)
968 {
969 printf("Resource: %s\nId: %s\n",
970 get_typename(top),
971 get_nameid_str(top->name));
972 switch(top->type)
973 {
974 case res_acc:
975 dump_accelerator(top->res.acc);
976 break;
977 case res_bmp:
978 dump_bitmap(top->res.bmp);
979 break;
980 case res_cur:
981 dump_cursor(top->res.cur);
982 break;
983 case res_curg:
984 dump_cursor_group(top->res.curg);
985 break;
986 case res_dlg:
987 dump_dialog(top->res.dlg);
988 break;
989 case res_dlgex:
990 dump_dialogex(top->res.dlgex);
991 break;
992 case res_fnt:
993 dump_font(top->res.fnt);
994 break;
995 case res_icog:
996 dump_icon_group(top->res.icog);
997 break;
998 case res_ico:
999 dump_icon(top->res.ico);
1000 break;
1001 case res_men:
1002 dump_menu(top->res.men);
1003 break;
1004 case res_menex:
1005 dump_menuex(top->res.menex);
1006 break;
1007 case res_rdt:
1008 dump_rcdata(top->res.rdt);
1009 break;
1010 case res_stt:
1011 dump_stringtable(top->res.stt);
1012 break;
1013 case res_usr:
1014 dump_user(top->res.usr);
1015 break;
1016 case res_msg:
1017 dump_messagetable(top->res.msg);
1018 break;
1019 case res_ver:
1020 dump_versioninfo(top->res.ver);
1021 break;
1022 case res_dlginit:
1023 dump_dlginit(top->res.dlgi);
1024 break;
1025 case res_toolbar:
1026 dump_toolbar(top->res.tbt);
1027 break;
1028 case res_anicur:
1029 case res_aniico:
1030 dump_ani_curico(top->res.ani);
1031 break;
1032 default:
1033 printf("Report this: Unknown resource type parsed %08x\n", top->type);
1034 }
1035 printf("\n");
1036 top = top->next;
1037 }
1038}
1039
Note: See TracBrowser for help on using the repository browser.