tools/wrc/dumpres.c

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