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

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

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